generic-library/openh264
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

remove "\n" which shoudl be added by the trace sink

Browse Source
This commit is contained in:
ruil2
2014-08-27 14:34:05 +08:00
parent bac5511694
commit 40e952f981
16 changed files with 249 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
codec/common/src/welsCodecTrace.cpp
View File

@@ -47,7 +47,7 @@
static void welsStderrTrace (void* ctx, int level, const char* string) { static void welsStderrTrace (void* ctx, int level, const char* string) {
fprintf (stderr, "%s", string); fprintf (stderr, "%s\n", string);
} }
welsCodecTrace::welsCodecTrace() { welsCodecTrace::welsCodecTrace() {

12
codec/decoder/core/inc/dec_golomb.h
View File

@@ -233,21 +233,21 @@ static inline int32_t BsGetTrailingBits (uint8_t* pBuf) {
//define macros to check syntax elements //define macros to check syntax elements
#define WELS_CHECK_SE_BOTH_ERROR(val, lower_bound, upper_bound, syntax_name, ret_code) do {\ #define WELS_CHECK_SE_BOTH_ERROR(val, lower_bound, upper_bound, syntax_name, ret_code) do {\
if ((val < lower_bound) || (val > upper_bound)) {\ if ((val < lower_bound) || (val > upper_bound)) {\
WelsLog(&(pCtx->sLogCtx), WELS_LOG_ERROR, "invalid syntax " syntax_name " %d\n", val);\ WelsLog(&(pCtx->sLogCtx), WELS_LOG_ERROR, "invalid syntax " syntax_name " %d", val);\
return ret_code;\ return ret_code;\
}\ }\
}while(0) }while(0)
#define WELS_CHECK_SE_LOWER_ERROR(val, lower_bound, syntax_name, ret_code) do {\ #define WELS_CHECK_SE_LOWER_ERROR(val, lower_bound, syntax_name, ret_code) do {\
if (val < lower_bound) {\ if (val < lower_bound) {\
WelsLog(&(pCtx->sLogCtx), WELS_LOG_ERROR, "invalid syntax " syntax_name " %d\n", val);\ WelsLog(&(pCtx->sLogCtx), WELS_LOG_ERROR, "invalid syntax " syntax_name " %d", val);\
return ret_code;\ return ret_code;\
}\ }\
}while(0) }while(0)
#define WELS_CHECK_SE_UPPER_ERROR(val, upper_bound, syntax_name, ret_code) do {\ #define WELS_CHECK_SE_UPPER_ERROR(val, upper_bound, syntax_name, ret_code) do {\
if (val > upper_bound) {\ if (val > upper_bound) {\
WelsLog(&(pCtx->sLogCtx), WELS_LOG_ERROR, "invalid syntax " syntax_name " %d\n", val);\ WelsLog(&(pCtx->sLogCtx), WELS_LOG_ERROR, "invalid syntax " syntax_name " %d", val);\
return ret_code;\ return ret_code;\
}\ }\
}while(0) }while(0)
@@ -273,19 +273,19 @@ if (val > upper_bound) {\
#define WELS_CHECK_SE_BOTH_WARNING(val, lower_bound, upper_bound, syntax_name) do {\ #define WELS_CHECK_SE_BOTH_WARNING(val, lower_bound, upper_bound, syntax_name) do {\
if ((val < lower_bound) || (val > upper_bound)) {\ if ((val < lower_bound) || (val > upper_bound)) {\
WelsLog(&(pCtx->sLogCtx), WELS_LOG_WARNING, "invalid syntax " syntax_name " %d\n", val);\ WelsLog(&(pCtx->sLogCtx), WELS_LOG_WARNING, "invalid syntax " syntax_name " %d", val);\
}\ }\
}while(0) }while(0)
#define WELS_CHECK_SE_LOWER_WARNING(val, lower_bound, syntax_name) do {\ #define WELS_CHECK_SE_LOWER_WARNING(val, lower_bound, syntax_name) do {\
if (val < lower_bound) {\ if (val < lower_bound) {\
WelsLog(&(pCtx->sLogCtx), WELS_LOG_WARNING, "invalid syntax " syntax_name " %d\n", val);\ WelsLog(&(pCtx->sLogCtx), WELS_LOG_WARNING, "invalid syntax " syntax_name " %d", val);\
}\ }\
}while(0) }while(0)
#define WELS_CHECK_SE_UPPER_WARNING(val, upper_bound, syntax_name) do {\ #define WELS_CHECK_SE_UPPER_WARNING(val, upper_bound, syntax_name) do {\
if (val > upper_bound) {\ if (val > upper_bound) {\
WelsLog(&(pCtx->sLogCtx), WELS_LOG_WARNING, "invalid syntax " syntax_name " %d\n", val);\ WelsLog(&(pCtx->sLogCtx), WELS_LOG_WARNING, "invalid syntax " syntax_name " %d", val);\
}\ }\
}while(0) }while(0)
// below define syntax element offset // below define syntax element offset

46
codec/decoder/core/src/au_parser.cpp
View File

@@ -146,7 +146,7 @@ uint8_t* ParseNalHeader (PWelsDecoderContext pCtx, SNalUnitHeader* pNalUnitHeade
|| pCtx->bSpsExistAheadFlag)) { || pCtx->bSpsExistAheadFlag)) {
if (pCtx->bPrintFrameErrorTraceFlag) { if (pCtx->bPrintFrameErrorTraceFlag) {
WelsLog (pLogCtx, WELS_LOG_WARNING, WelsLog (pLogCtx, WELS_LOG_WARNING,
"parse_nal(), no exist Sequence Parameter Sets ahead of sequence when try to decode NAL(type:%d).\n", "parse_nal(), no exist Sequence Parameter Sets ahead of sequence when try to decode NAL(type:%d).",
pNalUnitHeader->eNalUnitType); pNalUnitHeader->eNalUnitType);
} }
pCtx->iErrorCode = dsNoParamSets; pCtx->iErrorCode = dsNoParamSets;
@@ -156,7 +156,7 @@ uint8_t* ParseNalHeader (PWelsDecoderContext pCtx, SNalUnitHeader* pNalUnitHeade
|| pCtx->bPpsExistAheadFlag)) { || pCtx->bPpsExistAheadFlag)) {
if (pCtx->bPrintFrameErrorTraceFlag) { if (pCtx->bPrintFrameErrorTraceFlag) {
WelsLog (pLogCtx, WELS_LOG_WARNING, WelsLog (pLogCtx, WELS_LOG_WARNING,
"parse_nal(), no exist Picture Parameter Sets ahead of sequence when try to decode NAL(type:%d).\n", "parse_nal(), no exist Picture Parameter Sets ahead of sequence when try to decode NAL(type:%d).",
pNalUnitHeader->eNalUnitType); pNalUnitHeader->eNalUnitType);
} }
pCtx->iErrorCode = dsNoParamSets; pCtx->iErrorCode = dsNoParamSets;
@@ -167,7 +167,7 @@ uint8_t* ParseNalHeader (PWelsDecoderContext pCtx, SNalUnitHeader* pNalUnitHeade
|| pCtx->bPpsExistAheadFlag))) { || pCtx->bPpsExistAheadFlag))) {
if (pCtx->bPrintFrameErrorTraceFlag) { if (pCtx->bPrintFrameErrorTraceFlag) {
WelsLog (pLogCtx, WELS_LOG_WARNING, WelsLog (pLogCtx, WELS_LOG_WARNING,
"ParseNalHeader(), no exist Parameter Sets ahead of sequence when try to decode slice(type:%d).\n", "ParseNalHeader(), no exist Parameter Sets ahead of sequence when try to decode slice(type:%d).",
pNalUnitHeader->eNalUnitType); pNalUnitHeader->eNalUnitType);
} }
pCtx->iErrorCode |= dsNoParamSets; pCtx->iErrorCode |= dsNoParamSets;
@@ -204,7 +204,7 @@ uint8_t* ParseNalHeader (PWelsDecoderContext pCtx, SNalUnitHeader* pNalUnitHeade
DecodeNalHeaderExt (pCurNal, pNal); DecodeNalHeaderExt (pCurNal, pNal);
if ((pCurNal->sNalHeaderExt.uiQualityId != 0) || (pCurNal->sNalHeaderExt.bUseRefBasePicFlag != 0)) { if ((pCurNal->sNalHeaderExt.uiQualityId != 0) || (pCurNal->sNalHeaderExt.bUseRefBasePicFlag != 0)) {
WelsLog (pLogCtx, WELS_LOG_WARNING, WelsLog (pLogCtx, WELS_LOG_WARNING,
"ParseNalHeader() in Prefix Nal Unit:uiQualityId (%d) != 0, bUseRefBasePicFlag (%d) != 0, not supported!\n", "ParseNalHeader() in Prefix Nal Unit:uiQualityId (%d) != 0, bUseRefBasePicFlag (%d) != 0, not supported!",
pCurNal->sNalHeaderExt.uiQualityId, pCurNal->sNalHeaderExt.bUseRefBasePicFlag); pCurNal->sNalHeaderExt.uiQualityId, pCurNal->sNalHeaderExt.bUseRefBasePicFlag);
PAccessUnit pCurAu = pCtx->pAccessUnitList; PAccessUnit pCurAu = pCtx->pAccessUnitList;
uint32_t uiAvailNalNum = pCurAu->uiAvailUnitsNum; uint32_t uiAvailNalNum = pCurAu->uiAvailUnitsNum;
@@ -246,7 +246,7 @@ uint8_t* ParseNalHeader (PWelsDecoderContext pCtx, SNalUnitHeader* pNalUnitHeade
uint32_t uiAvailNalNum; uint32_t uiAvailNalNum;
pCurNal = MemGetNextNal (&pCtx->pAccessUnitList); pCurNal = MemGetNextNal (&pCtx->pAccessUnitList);
if (NULL == pCurNal) { if (NULL == pCurNal) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "MemGetNextNal() fail due out of memory.\n"); WelsLog (pLogCtx, WELS_LOG_ERROR, "MemGetNextNal() fail due out of memory.");
pCtx->iErrorCode |= dsOutOfMemory; pCtx->iErrorCode |= dsOutOfMemory;
return NULL; return NULL;
} }
@@ -274,10 +274,10 @@ uint8_t* ParseNalHeader (PWelsDecoderContext pCtx, SNalUnitHeader* pNalUnitHeade
if (pCurNal->sNalHeaderExt.uiQualityId != 0 || if (pCurNal->sNalHeaderExt.uiQualityId != 0 ||
pCurNal->sNalHeaderExt.bUseRefBasePicFlag) { pCurNal->sNalHeaderExt.bUseRefBasePicFlag) {
if (pCurNal->sNalHeaderExt.uiQualityId != 0) if (pCurNal->sNalHeaderExt.uiQualityId != 0)
WelsLog (pLogCtx, WELS_LOG_WARNING, "ParseNalHeader():uiQualityId (%d) != 0, MGS not supported!\n", WelsLog (pLogCtx, WELS_LOG_WARNING, "ParseNalHeader():uiQualityId (%d) != 0, MGS not supported!",
pCurNal->sNalHeaderExt.uiQualityId); pCurNal->sNalHeaderExt.uiQualityId);
if (pCurNal->sNalHeaderExt.bUseRefBasePicFlag != 0) if (pCurNal->sNalHeaderExt.bUseRefBasePicFlag != 0)
WelsLog (pLogCtx, WELS_LOG_WARNING, "ParseNalHeader():bUseRefBasePicFlag (%d) != 0, MGS not supported!\n", WelsLog (pLogCtx, WELS_LOG_WARNING, "ParseNalHeader():bUseRefBasePicFlag (%d) != 0, MGS not supported!",
pCurNal->sNalHeaderExt.bUseRefBasePicFlag); pCurNal->sNalHeaderExt.bUseRefBasePicFlag);
ForceClearCurrentNal (pCurAu); ForceClearCurrentNal (pCurAu);
@@ -630,7 +630,7 @@ int32_t DecodeSpsSvcExt (PWelsDecoderContext pCtx, PSubsetSps pSpsExt, PBitStrin
pExt->uiExtendedSpatialScalability = uiCode; pExt->uiExtendedSpatialScalability = uiCode;
if (pExt->uiExtendedSpatialScalability > 2) { if (pExt->uiExtendedSpatialScalability > 2) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING,
"DecodeSpsSvcExt():extended_spatial_scalability (%d) != 0, ESS not supported!\n", "DecodeSpsSvcExt():extended_spatial_scalability (%d) != 0, ESS not supported!",
pExt->uiExtendedSpatialScalability); pExt->uiExtendedSpatialScalability);
return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_INVALID_ESS); return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_INVALID_ESS);
} }
@@ -824,21 +824,21 @@ int32_t ParseSps (PWelsDecoderContext pCtx, PBitStringAux pBsAux, int32_t* pPicW
WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //chroma_format_idc WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //chroma_format_idc
pSps->uiChromaFormatIdc = uiCode; pSps->uiChromaFormatIdc = uiCode;
if (pSps->uiChromaFormatIdc != 1) { if (pSps->uiChromaFormatIdc != 1) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "ParseSps(): chroma_format_idc (%d) = 1 supported.\n", WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "ParseSps(): chroma_format_idc (%d) = 1 supported.",
pSps->uiChromaFormatIdc); pSps->uiChromaFormatIdc);
return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE); return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE);
} }
pSps->uiChromaArrayType = pSps->uiChromaFormatIdc; pSps->uiChromaArrayType = pSps->uiChromaFormatIdc;
WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //bit_depth_luma_minus8 WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //bit_depth_luma_minus8
if (uiCode != 0) { if (uiCode != 0) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "ParseSps(): bit_depth_luma (%d) Only 8 bit supported.\n", 8 + uiCode); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "ParseSps(): bit_depth_luma (%d) Only 8 bit supported.", 8 + uiCode);
return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE); return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE);
} }
pSps->uiBitDepthLuma = 8; pSps->uiBitDepthLuma = 8;
WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //bit_depth_chroma_minus8 WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //bit_depth_chroma_minus8
if (uiCode != 0) { if (uiCode != 0) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "ParseSps(): bit_depth_chroma (%d). Only 8 bit supported.\n", 8 + uiCode); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "ParseSps(): bit_depth_chroma (%d). Only 8 bit supported.", 8 + uiCode);
return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE); return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE);
} }
pSps->uiBitDepthChroma = 8; pSps->uiBitDepthChroma = 8;
@@ -850,7 +850,7 @@ int32_t ParseSps (PWelsDecoderContext pCtx, PBitStringAux pBsAux, int32_t* pPicW
if (pSps->bSeqScalingMatrixPresentFlag) { // For high profile, it is not used in current application. FIXME if (pSps->bSeqScalingMatrixPresentFlag) { // For high profile, it is not used in current application. FIXME
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING,
"ParseSps(): seq_scaling_matrix_present_flag (%d). Feature not supported.\n", "ParseSps(): seq_scaling_matrix_present_flag (%d). Feature not supported.",
pSps->bSeqScalingMatrixPresentFlag); pSps->bSeqScalingMatrixPresentFlag);
return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE); return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_NON_BASELINE);
} }
@@ -888,7 +888,7 @@ int32_t ParseSps (PWelsDecoderContext pCtx, PBitStringAux pBsAux, int32_t* pPicW
} }
} }
if (pSps->uiPocType > 2) { if (pSps->uiPocType > 2) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, " illegal pic_order_cnt_type: %d ! \n", pSps->uiPocType); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, " illegal pic_order_cnt_type: %d ! ", pSps->uiPocType);
return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_INVALID_POC_TYPE); return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_INVALID_POC_TYPE);
} }
@@ -899,24 +899,24 @@ int32_t ParseSps (PWelsDecoderContext pCtx, PBitStringAux pBsAux, int32_t* pPicW
WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //pic_width_in_mbs_minus1 WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //pic_width_in_mbs_minus1
pSps->iMbWidth = PIC_WIDTH_IN_MBS_OFFSET + uiCode; pSps->iMbWidth = PIC_WIDTH_IN_MBS_OFFSET + uiCode;
if (pSps->iMbWidth > MAX_MB_SIZE) { if (pSps->iMbWidth > MAX_MB_SIZE) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, "pic_width_in_mbs(%d) exceeds the maximum allowed!\n", pSps->iMbWidth); WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, "pic_width_in_mbs(%d) exceeds the maximum allowed!", pSps->iMbWidth);
return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_INVALID_MAX_MB_SIZE); return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_INVALID_MAX_MB_SIZE);
} }
if (((uint64_t)pSps->iMbWidth * (uint64_t)pSps->iMbWidth) > (uint64_t) (8 * pSLevelLimits->uiMaxFS)) { if (((uint64_t)pSps->iMbWidth * (uint64_t)pSps->iMbWidth) > (uint64_t) (8 * pSLevelLimits->uiMaxFS)) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, " the pic_width_in_mbs exceeds the level limits!\n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, " the pic_width_in_mbs exceeds the level limits!");
} }
WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //pic_height_in_map_units_minus1 WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //pic_height_in_map_units_minus1
pSps->iMbHeight = PIC_HEIGHT_IN_MAP_UNITS_OFFSET + uiCode; pSps->iMbHeight = PIC_HEIGHT_IN_MAP_UNITS_OFFSET + uiCode;
if (pSps->iMbHeight > MAX_MB_SIZE) { if (pSps->iMbHeight > MAX_MB_SIZE) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, "pic_height_in_mbs(%d) exceeds the maximum allowed!\n", pSps->iMbHeight); WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, "pic_height_in_mbs(%d) exceeds the maximum allowed!", pSps->iMbHeight);
return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_INVALID_MAX_MB_SIZE); return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_INVALID_MAX_MB_SIZE);
} }
if (((uint64_t)pSps->iMbHeight * (uint64_t)pSps->iMbHeight) > (uint64_t) (8 * pSLevelLimits->uiMaxFS)) { if (((uint64_t)pSps->iMbHeight * (uint64_t)pSps->iMbHeight) > (uint64_t) (8 * pSLevelLimits->uiMaxFS)) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, " the pic_height_in_mbs exceeds the level limits!\n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, " the pic_height_in_mbs exceeds the level limits!");
} }
uint32_t uiTmp32 = pSps->iMbWidth * pSps->iMbHeight; uint32_t uiTmp32 = pSps->iMbWidth * pSps->iMbHeight;
if (uiTmp32 > (uint32_t)pSLevelLimits->uiMaxFS) { if (uiTmp32 > (uint32_t)pSLevelLimits->uiMaxFS) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, " the total count of mb exceeds the level limits!\n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, " the total count of mb exceeds the level limits!");
} }
pSps->uiTotalMbCount = uiTmp32; pSps->uiTotalMbCount = uiTmp32;
WELS_CHECK_SE_UPPER_ERROR (pSps->iNumRefFrames, SPS_MAX_NUM_REF_FRAMES_MAX, "max_num_ref_frames", WELS_CHECK_SE_UPPER_ERROR (pSps->iNumRefFrames, SPS_MAX_NUM_REF_FRAMES_MAX, "max_num_ref_frames",
@@ -927,12 +927,12 @@ int32_t ParseSps (PWelsDecoderContext pCtx, PBitStringAux pBsAux, int32_t* pPicW
if (uiMaxDpbFrames > SPS_MAX_NUM_REF_FRAMES_MAX) if (uiMaxDpbFrames > SPS_MAX_NUM_REF_FRAMES_MAX)
uiMaxDpbFrames = SPS_MAX_NUM_REF_FRAMES_MAX; uiMaxDpbFrames = SPS_MAX_NUM_REF_FRAMES_MAX;
if ((uint32_t)pSps->iNumRefFrames > uiMaxDpbFrames) { if ((uint32_t)pSps->iNumRefFrames > uiMaxDpbFrames) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, " max_num_ref_frames exceeds level limits!\n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, " max_num_ref_frames exceeds level limits!");
} }
WELS_READ_VERIFY (BsGetOneBit (pBs, &uiCode)); //frame_mbs_only_flag WELS_READ_VERIFY (BsGetOneBit (pBs, &uiCode)); //frame_mbs_only_flag
pSps->bFrameMbsOnlyFlag = !!uiCode; pSps->bFrameMbsOnlyFlag = !!uiCode;
if (!pSps->bFrameMbsOnlyFlag) { if (!pSps->bFrameMbsOnlyFlag) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "ParseSps(): frame_mbs_only_flag (%d) not supported.\n", WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "ParseSps(): frame_mbs_only_flag (%d) not supported.",
pSps->bFrameMbsOnlyFlag); pSps->bFrameMbsOnlyFlag);
return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_MBAFF); return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_MBAFF);
} }
@@ -946,14 +946,14 @@ int32_t ParseSps (PWelsDecoderContext pCtx, PBitStringAux pBsAux, int32_t* pPicW
WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //frame_crop_right_offset WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //frame_crop_right_offset
pSps->sFrameCrop.iRightOffset = uiCode; pSps->sFrameCrop.iRightOffset = uiCode;
if ((pSps->sFrameCrop.iLeftOffset + pSps->sFrameCrop.iRightOffset) > ((int32_t)pSps->iMbWidth * 16 / 2)) { if ((pSps->sFrameCrop.iLeftOffset + pSps->sFrameCrop.iRightOffset) > ((int32_t)pSps->iMbWidth * 16 / 2)) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "frame_crop_left_offset + frame_crop_right_offset exceeds limits!\n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "frame_crop_left_offset + frame_crop_right_offset exceeds limits!");
} }
WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //frame_crop_top_offset WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //frame_crop_top_offset
pSps->sFrameCrop.iTopOffset = uiCode; pSps->sFrameCrop.iTopOffset = uiCode;
WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //frame_crop_bottom_offset WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //frame_crop_bottom_offset
pSps->sFrameCrop.iBottomOffset = uiCode; pSps->sFrameCrop.iBottomOffset = uiCode;
if ((pSps->sFrameCrop.iTopOffset + pSps->sFrameCrop.iBottomOffset) > ((int32_t)pSps->iMbHeight * 16 / 2)) { if ((pSps->sFrameCrop.iTopOffset + pSps->sFrameCrop.iBottomOffset) > ((int32_t)pSps->iMbHeight * 16 / 2)) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "frame_crop_top_offset + frame_crop_right_offset exceeds limits!\n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "frame_crop_top_offset + frame_crop_right_offset exceeds limits!");
} }
} else { } else {
pSps->sFrameCrop.iLeftOffset = 0; // frame_crop_left_offset pSps->sFrameCrop.iLeftOffset = 0; // frame_crop_left_offset
@@ -1090,7 +1090,7 @@ int32_t ParsePps (PWelsDecoderContext pCtx, PPps pPpsList, PBitStringAux pBsAux)
WELS_READ_VERIFY (BsGetUe (pBsAux, &uiCode)); //slice_group_map_type WELS_READ_VERIFY (BsGetUe (pBsAux, &uiCode)); //slice_group_map_type
pPps->uiSliceGroupMapType = uiCode; pPps->uiSliceGroupMapType = uiCode;
if (pPps->uiSliceGroupMapType > 1) { if (pPps->uiSliceGroupMapType > 1) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "ParsePps(): slice_group_map_type (%d): support only 0,1.\n", WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "ParsePps(): slice_group_map_type (%d): support only 0,1.",
pPps->uiSliceGroupMapType); pPps->uiSliceGroupMapType);
return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_FMOTYPE); return GENERATE_ERROR_NO (ERR_LEVEL_PARAM_SETS, ERR_INFO_UNSUPPORTED_FMOTYPE);
} }

14
codec/decoder/core/src/decode_slice.cpp
View File

@@ -91,7 +91,7 @@ int32_t WelsTargetSliceConstruction (PWelsDecoderContext pCtx) {
if (WelsTargetMbConstruction (pCtx)) { if (WelsTargetMbConstruction (pCtx)) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING,
"WelsTargetSliceConstruction():::MB(%d, %d) construction error. pCurSlice_type:%d\n", "WelsTargetSliceConstruction():::MB(%d, %d) construction error. pCurSlice_type:%d",
pCurLayer->iMbX, pCurLayer->iMbY, pCurSlice->eSliceType); pCurLayer->iMbX, pCurLayer->iMbY, pCurSlice->eSliceType);
return -1; return -1;
@@ -105,7 +105,7 @@ int32_t WelsTargetSliceConstruction (PWelsDecoderContext pCtx) {
if (pCtx->iTotalNumMbRec > iTotalMbTargetLayer) { if (pCtx->iTotalNumMbRec > iTotalMbTargetLayer) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING,
"WelsTargetSliceConstruction():::pCtx->iTotalNumMbRec:%d, iTotalMbTargetLayer:%d\n", "WelsTargetSliceConstruction():::pCtx->iTotalNumMbRec:%d, iTotalMbTargetLayer:%d",
pCtx->iTotalNumMbRec, iTotalMbTargetLayer); pCtx->iTotalNumMbRec, iTotalMbTargetLayer);
return -1; return -1;
@@ -287,7 +287,7 @@ int32_t WelsTargetMbConstruction (PWelsDecoderContext pCtx) {
WelsMbInterConstruction (pCtx, pCurLayer); WelsMbInterConstruction (pCtx, pCurLayer);
} }
} else { } else {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "WelsTargetMbConstruction():::::Unknown MB type: %d\n", WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "WelsTargetMbConstruction():::::Unknown MB type: %d",
pCurLayer->pMbType[pCurLayer->iMbXyIndex]); pCurLayer->pMbType[pCurLayer->iMbXyIndex]);
return -1; return -1;
} }
@@ -419,7 +419,7 @@ int32_t WelsDecodeSlice (PWelsDecoderContext pCtx, bool bFirstSliceInLayer, PNal
} }
if (iUsedBits > pBs->iBits) { //When BS incomplete, as long as find it, SHOULD stop decoding to avoid mosaic or crash. if (iUsedBits > pBs->iBits) { //When BS incomplete, as long as find it, SHOULD stop decoding to avoid mosaic or crash.
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING,
"WelsDecodeSlice()::::pBs incomplete, iUsedBits:%"PRId64" > pBs->iBits:%d, MUST stop decoding.\n", "WelsDecodeSlice()::::pBs incomplete, iUsedBits:%"PRId64" > pBs->iBits:%d, MUST stop decoding.",
(int64_t) iUsedBits, pBs->iBits); (int64_t) iUsedBits, pBs->iBits);
return -1; return -1;
} }
@@ -690,7 +690,7 @@ int32_t WelsDecodeMbCavlcISlice (PWelsDecoderContext pCtx, PNalUnit pNalCur) {
if (!iBaseModeFlag) { if (!iBaseModeFlag) {
iRet = WelsActualDecodeMbCavlcISlice (pCtx); iRet = WelsActualDecodeMbCavlcISlice (pCtx);
} else { } else {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "iBaseModeFlag (%d) != 0, inter-layer prediction not supported.\n", WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "iBaseModeFlag (%d) != 0, inter-layer prediction not supported.",
iBaseModeFlag); iBaseModeFlag);
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_ILP); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_ILP);
} }
@@ -747,7 +747,7 @@ int32_t WelsActualDecodeMbCavlcPSlice (PWelsDecoderContext pCtx) {
if (pCurLayer->pResidualPredFlag[iMbXy] == 0) { if (pCurLayer->pResidualPredFlag[iMbXy] == 0) {
pCurLayer->pInterPredictionDoneFlag[iMbXy] = 0; pCurLayer->pInterPredictionDoneFlag[iMbXy] = 0;
} else { } else {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "residual_pred_flag = 1 not supported.\n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "residual_pred_flag = 1 not supported.");
return -1; return -1;
} }
} else { //intra MB type } else { //intra MB type
@@ -1044,7 +1044,7 @@ int32_t WelsDecodeMbCavlcPSlice (PWelsDecoderContext pCtx, PNalUnit pNalCur) {
if (!iBaseModeFlag) { if (!iBaseModeFlag) {
iRet = WelsActualDecodeMbCavlcPSlice (pCtx); iRet = WelsActualDecodeMbCavlcPSlice (pCtx);
} else { } else {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "iBaseModeFlag (%d) != 0, inter-layer prediction not supported.\n", WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "iBaseModeFlag (%d) != 0, inter-layer prediction not supported.",
iBaseModeFlag); iBaseModeFlag);
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_ILP); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_ILP);
} }

8
codec/decoder/core/src/decoder.cpp
View File

@@ -341,7 +341,7 @@ int32_t DecoderConfigParam (PWelsDecoderContext pCtx, const SDecodingParam* kpPa
pCtx->eVideoType = VIDEO_BITSTREAM_DEFAULT; pCtx->eVideoType = VIDEO_BITSTREAM_DEFAULT;
} }
WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, "eVideoType: %d\n", pCtx->eVideoType); WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, "eVideoType: %d", pCtx->eVideoType);
return 0; return 0;
} }
@@ -596,7 +596,7 @@ int32_t DecoderSetCsp (PWelsDecoderContext pCtx, const int32_t kiColorFormat) {
//For now, support only videoFormatI420! //For now, support only videoFormatI420!
if (kiColorFormat != (int32_t) videoFormatI420) { if (kiColorFormat != (int32_t) videoFormatI420) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "Support I420 output only for now! Change to I420...\n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "Support I420 output only for now! Change to I420...");
pCtx->pParam->eOutputColorFormat = pCtx->eOutputColorFormat = videoFormatI420; pCtx->pParam->eOutputColorFormat = pCtx->eOutputColorFormat = videoFormatI420;
} }
@@ -620,7 +620,7 @@ int32_t SyncPictureResolutionExt (PWelsDecoderContext pCtx, const int32_t kiMbWi
iErr = WelsRequestMem (pCtx, kiMbWidth, kiMbHeight); // common memory used iErr = WelsRequestMem (pCtx, kiMbWidth, kiMbHeight); // common memory used
if (ERR_NONE != iErr) { if (ERR_NONE != iErr) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING,
"SyncPictureResolutionExt()::WelsRequestMem--buffer allocated failure.\n"); "SyncPictureResolutionExt()::WelsRequestMem--buffer allocated failure.");
pCtx->iErrorCode = dsOutOfMemory; pCtx->iErrorCode = dsOutOfMemory;
return iErr; return iErr;
} }
@@ -628,7 +628,7 @@ int32_t SyncPictureResolutionExt (PWelsDecoderContext pCtx, const int32_t kiMbWi
iErr = InitialDqLayersContext (pCtx, kiPicWidth, kiPicHeight); iErr = InitialDqLayersContext (pCtx, kiPicWidth, kiPicHeight);
if (ERR_NONE != iErr) { if (ERR_NONE != iErr) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING,
"SyncPictureResolutionExt()::InitialDqLayersContext--buffer allocated failure.\n"); "SyncPictureResolutionExt()::InitialDqLayersContext--buffer allocated failure.");
pCtx->iErrorCode = dsOutOfMemory; pCtx->iErrorCode = dsOutOfMemory;
} }

62
codec/decoder/core/src/decoder_core.cpp
View File

@@ -66,7 +66,7 @@ static inline int32_t DecodeFrameConstruction (PWelsDecoderContext pCtx, uint8_t
if (pCtx->iTotalNumMbRec == kiTotalNumMbInCurLayer) { if (pCtx->iTotalNumMbRec == kiTotalNumMbInCurLayer) {
pCtx->bPrintFrameErrorTraceFlag = true; pCtx->bPrintFrameErrorTraceFlag = true;
WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO,
"DecodeFrameConstruction()::::output first frame of new sequence, %d x %d, crop_left:%d, crop_right:%d, crop_top:%d, crop_bottom:%d, ignored error packet:%d.\n", "DecodeFrameConstruction()::::output first frame of new sequence, %d x %d, crop_left:%d, crop_right:%d, crop_top:%d, crop_bottom:%d, ignored error packet:%d.",
kiWidth, kiHeight, pCtx->sFrameCrop.iLeftOffset, pCtx->sFrameCrop.iRightOffset, pCtx->sFrameCrop.iTopOffset, kiWidth, kiHeight, pCtx->sFrameCrop.iLeftOffset, pCtx->sFrameCrop.iRightOffset, pCtx->sFrameCrop.iTopOffset,
pCtx->sFrameCrop.iBottomOffset, pCtx->iIgnoredErrorInfoPacketCount); pCtx->sFrameCrop.iBottomOffset, pCtx->iIgnoredErrorInfoPacketCount);
pCtx->iIgnoredErrorInfoPacketCount = 0; pCtx->iIgnoredErrorInfoPacketCount = 0;
@@ -75,7 +75,7 @@ static inline int32_t DecodeFrameConstruction (PWelsDecoderContext pCtx, uint8_t
if (pCtx->iTotalNumMbRec != kiTotalNumMbInCurLayer) { if (pCtx->iTotalNumMbRec != kiTotalNumMbInCurLayer) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_DEBUG, WelsLog (& (pCtx->sLogCtx), WELS_LOG_DEBUG,
"DecodeFrameConstruction():::iTotalNumMbRec:%d, total_num_mb_sps:%d, cur_layer_mb_width:%d, cur_layer_mb_height:%d \n", "DecodeFrameConstruction():::iTotalNumMbRec:%d, total_num_mb_sps:%d, cur_layer_mb_width:%d, cur_layer_mb_height:%d ",
pCtx->iTotalNumMbRec, kiTotalNumMbInCurLayer, pCurDq->iMbWidth, pCurDq->iMbHeight); pCtx->iTotalNumMbRec, kiTotalNumMbInCurLayer, pCurDq->iMbWidth, pCurDq->iMbHeight);
bFrameCompleteFlag = false; //return later after output buffer is done bFrameCompleteFlag = false; //return later after output buffer is done
if (pCtx->bInstantDecFlag) //no-delay decoding, wait for new slice if (pCtx->bInstantDecFlag) //no-delay decoding, wait for new slice
@@ -501,7 +501,7 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //slice_type WELS_READ_VERIFY (BsGetUe (pBs, &uiCode)); //slice_type
uiSliceType = uiCode; uiSliceType = uiCode;
if (uiSliceType > 9) { if (uiSliceType > 9) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "slice type too large (%d) at first_mb(%d)\n", uiSliceType, WelsLog (pLogCtx, WELS_LOG_WARNING, "slice type too large (%d) at first_mb(%d)", uiSliceType,
pSliceHead->iFirstMbInSlice); pSliceHead->iFirstMbInSlice);
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_SLICE_TYPE); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_SLICE_TYPE);
} }
@@ -509,17 +509,17 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
uiSliceType -= 5; uiSliceType -= 5;
if (B_SLICE == uiSliceType) { if (B_SLICE == uiSliceType) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "ParseSliceHeaderSyntaxs(): B slice not supported.\n"); WelsLog (pLogCtx, WELS_LOG_WARNING, "ParseSliceHeaderSyntaxs(): B slice not supported.");
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_BIPRED); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_BIPRED);
} }
if ((NAL_UNIT_CODED_SLICE_IDR == eNalType) && (I_SLICE != uiSliceType)) { if ((NAL_UNIT_CODED_SLICE_IDR == eNalType) && (I_SLICE != uiSliceType)) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "Invalid slice type(%d) in IDR picture. \n", uiSliceType); WelsLog (pLogCtx, WELS_LOG_WARNING, "Invalid slice type(%d) in IDR picture. ", uiSliceType);
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_SLICE_TYPE); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_SLICE_TYPE);
} }
if (kbExtensionFlag) { if (kbExtensionFlag) {
if (uiSliceType > 2) { if (uiSliceType > 2) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "Invalid slice type(%d).\n", uiSliceType); WelsLog (pLogCtx, WELS_LOG_WARNING, "Invalid slice type(%d).", uiSliceType);
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_SLICE_TYPE); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_SLICE_TYPE);
} }
} }
@@ -530,20 +530,20 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
iPpsId = uiCode; iPpsId = uiCode;
if (iPpsId >= MAX_PPS_COUNT) { if (iPpsId >= MAX_PPS_COUNT) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "iPpsId out of range\n"); WelsLog (pLogCtx, WELS_LOG_WARNING, "iPpsId out of range");
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_PPS_ID_OVERFLOW); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_PPS_ID_OVERFLOW);
} }
//add check PPS available here //add check PPS available here
if (pCtx->bPpsAvailFlags[iPpsId] == false) { if (pCtx->bPpsAvailFlags[iPpsId] == false) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "PPS id is invalid!\n"); WelsLog (pLogCtx, WELS_LOG_ERROR, "PPS id is invalid!");
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_PPS_ID); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_PPS_ID);
} }
pPps = &pCtx->sPpsBuffer[iPpsId]; pPps = &pCtx->sPpsBuffer[iPpsId];
if (pPps->uiNumSliceGroups == 0) { if (pPps->uiNumSliceGroups == 0) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "non existing PPS referenced\n"); WelsLog (pLogCtx, WELS_LOG_WARNING, "non existing PPS referenced");
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_NO_PARAM_SETS); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_NO_PARAM_SETS);
} }
@@ -551,12 +551,12 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
pSubsetSps = &pCtx->sSubsetSpsBuffer[pPps->iSpsId]; pSubsetSps = &pCtx->sSubsetSpsBuffer[pPps->iSpsId];
pSps = &pSubsetSps->sSps; pSps = &pSubsetSps->sSps;
if (pCtx->bSubspsAvailFlags[pPps->iSpsId] == false) { if (pCtx->bSubspsAvailFlags[pPps->iSpsId] == false) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "SPS id is invalid!\n"); WelsLog (pLogCtx, WELS_LOG_ERROR, "SPS id is invalid!");
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_SPS_ID); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_SPS_ID);
} }
} else { } else {
if (pCtx->bSpsAvailFlags[pPps->iSpsId] == false) { if (pCtx->bSpsAvailFlags[pPps->iSpsId] == false) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "SPS id is invalid!\n"); WelsLog (pLogCtx, WELS_LOG_ERROR, "SPS id is invalid!");
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_SPS_ID); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_SPS_ID);
} }
pSps = &pCtx->sSpsBuffer[pPps->iSpsId]; pSps = &pCtx->sSpsBuffer[pPps->iSpsId];
@@ -571,7 +571,7 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
bIdrFlag = (!kbExtensionFlag && eNalType == NAL_UNIT_CODED_SLICE_IDR) || (kbExtensionFlag && pNalHeaderExt->bIdrFlag); bIdrFlag = (!kbExtensionFlag && eNalType == NAL_UNIT_CODED_SLICE_IDR) || (kbExtensionFlag && pNalHeaderExt->bIdrFlag);
if (pSps->uiLog2MaxFrameNum == 0) { if (pSps->uiLog2MaxFrameNum == 0) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "non existing SPS referenced\n"); WelsLog (pLogCtx, WELS_LOG_WARNING, "non existing SPS referenced");
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_NO_PARAM_SETS); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_NO_PARAM_SETS);
} }
// check first_mb_in_slice // check first_mb_in_slice
@@ -583,7 +583,7 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
pSliceHead->bFieldPicFlag = false; pSliceHead->bFieldPicFlag = false;
pSliceHead->bBottomFiledFlag = false; pSliceHead->bBottomFiledFlag = false;
if (!pSps->bFrameMbsOnlyFlag) { if (!pSps->bFrameMbsOnlyFlag) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "ParseSliceHeaderSyntaxs(): frame_mbs_only_flag = %d not supported. \n", WelsLog (pLogCtx, WELS_LOG_WARNING, "ParseSliceHeaderSyntaxs(): frame_mbs_only_flag = %d not supported. ",
pSps->bFrameMbsOnlyFlag); pSps->bFrameMbsOnlyFlag);
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_MBAFF); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_MBAFF);
} }
@@ -593,7 +593,7 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
if (bIdrFlag) { if (bIdrFlag) {
if (pSliceHead->iFrameNum != 0) { if (pSliceHead->iFrameNum != 0) {
WelsLog (pLogCtx, WELS_LOG_WARNING, WelsLog (pLogCtx, WELS_LOG_WARNING,
"ParseSliceHeaderSyntaxs(), invaild frame number: %d due to IDR frame introduced!\n", "ParseSliceHeaderSyntaxs(), invaild frame number: %d due to IDR frame introduced!",
pSliceHead->iFrameNum); pSliceHead->iFrameNum);
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_FRAME_NUM); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_FRAME_NUM);
} }
@@ -655,14 +655,14 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
} }
if (pSliceHead->uiRefCount[0] > MAX_REF_PIC_COUNT || pSliceHead->uiRefCount[1] > MAX_REF_PIC_COUNT) { if (pSliceHead->uiRefCount[0] > MAX_REF_PIC_COUNT || pSliceHead->uiRefCount[1] > MAX_REF_PIC_COUNT) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "reference overflow\n"); WelsLog (pLogCtx, WELS_LOG_WARNING, "reference overflow");
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_REF_COUNT_OVERFLOW); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_REF_COUNT_OVERFLOW);
} }
if (BASE_QUALITY_ID == uiQualityId) { if (BASE_QUALITY_ID == uiQualityId) {
iRet = ParseRefPicListReordering (pBs, pSliceHead); iRet = ParseRefPicListReordering (pBs, pSliceHead);
if (iRet != ERR_NONE) { if (iRet != ERR_NONE) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "invalid ref pPic list reordering syntaxs!\n"); WelsLog (pLogCtx, WELS_LOG_WARNING, "invalid ref pPic list reordering syntaxs!");
return iRet; return iRet;
} }
@@ -684,7 +684,7 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
pSliceHeadExt->bStoreRefBasePicFlag = !!uiCode; pSliceHeadExt->bStoreRefBasePicFlag = !!uiCode;
if ((pNalHeaderExt->bUseRefBasePicFlag || pSliceHeadExt->bStoreRefBasePicFlag) && !bIdrFlag) { if ((pNalHeaderExt->bUseRefBasePicFlag || pSliceHeadExt->bStoreRefBasePicFlag) && !bIdrFlag) {
WelsLog (pLogCtx, WELS_LOG_WARNING, WelsLog (pLogCtx, WELS_LOG_WARNING,
"ParseSliceHeaderSyntaxs(): bUseRefBasePicFlag or bStoreRefBasePicFlag = 1 not supported.\n"); "ParseSliceHeaderSyntaxs(): bUseRefBasePicFlag or bStoreRefBasePicFlag = 1 not supported.");
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_ILP); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_ILP);
} }
} }
@@ -692,7 +692,7 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
} }
if (pPps->bEntropyCodingModeFlag) { if (pPps->bEntropyCodingModeFlag) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "ParseSliceHeaderSyntaxs(): CABAC in Enhancement layer not supported.\n"); WelsLog (pLogCtx, WELS_LOG_WARNING, "ParseSliceHeaderSyntaxs(): CABAC in Enhancement layer not supported.");
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_CABAC_EL); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_CABAC_EL);
} }
@@ -700,14 +700,14 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
pSliceHead->iSliceQpDelta = iCode; pSliceHead->iSliceQpDelta = iCode;
pSliceHead->iSliceQp = pPps->iPicInitQp + pSliceHead->iSliceQpDelta; pSliceHead->iSliceQp = pPps->iPicInitQp + pSliceHead->iSliceQpDelta;
if (pSliceHead->iSliceQp < 0 || pSliceHead->iSliceQp > 51) { if (pSliceHead->iSliceQp < 0 || pSliceHead->iSliceQp > 51) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "QP %d out of range\n", pSliceHead->iSliceQp); WelsLog (pLogCtx, WELS_LOG_WARNING, "QP %d out of range", pSliceHead->iSliceQp);
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_QP); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_INVALID_QP);
} }
//FIXME qscale / qp ... stuff //FIXME qscale / qp ... stuff
if (!kbExtensionFlag) { if (!kbExtensionFlag) {
if (uiSliceType == SP_SLICE || uiSliceType == SI_SLICE) { if (uiSliceType == SP_SLICE || uiSliceType == SI_SLICE) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "SP/SI not supported\n"); WelsLog (pLogCtx, WELS_LOG_WARNING, "SP/SI not supported");
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_SPSI); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_SPSI);
} }
} }
@@ -720,7 +720,7 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
pSliceHead->uiDisableDeblockingFilterIdc = uiCode; pSliceHead->uiDisableDeblockingFilterIdc = uiCode;
//refer to JVT-X201wcm1.doc G.7.4.3.4--2010.4.20 //refer to JVT-X201wcm1.doc G.7.4.3.4--2010.4.20
if (pSliceHead->uiDisableDeblockingFilterIdc > 6) { if (pSliceHead->uiDisableDeblockingFilterIdc > 6) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "disable_deblock_filter_idc (%d) out of range [0, 6]\n", WelsLog (pLogCtx, WELS_LOG_WARNING, "disable_deblock_filter_idc (%d) out of range [0, 6]",
pSliceHead->uiDisableDeblockingFilterIdc); pSliceHead->uiDisableDeblockingFilterIdc);
return ERR_INFO_INVALID_DBLOCKING_IDC; return ERR_INFO_INVALID_DBLOCKING_IDC;
} }
@@ -767,7 +767,7 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
pSliceHeadExt->uiDisableInterLayerDeblockingFilterIdc = uiCode; pSliceHeadExt->uiDisableInterLayerDeblockingFilterIdc = uiCode;
//refer to JVT-X201wcm1.doc G.7.4.3.4--2010.4.20 //refer to JVT-X201wcm1.doc G.7.4.3.4--2010.4.20
if (pSliceHeadExt->uiDisableInterLayerDeblockingFilterIdc > 6) { if (pSliceHeadExt->uiDisableInterLayerDeblockingFilterIdc > 6) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "disable_inter_layer_deblock_filter_idc (%d) out of range [0, 6]\n", WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "disable_inter_layer_deblock_filter_idc (%d) out of range [0, 6]",
pSliceHeadExt->uiDisableInterLayerDeblockingFilterIdc); pSliceHeadExt->uiDisableInterLayerDeblockingFilterIdc);
return ERR_INFO_INVALID_DBLOCKING_IDC; return ERR_INFO_INVALID_DBLOCKING_IDC;
} }
@@ -804,7 +804,7 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
(pos.iTopOffset + pos.iBottomOffset) / (1 + pSliceHead->bFieldPicFlag); (pos.iTopOffset + pos.iBottomOffset) / (1 + pSliceHead->bFieldPicFlag);
} }
} else if (uiQualityId > BASE_QUALITY_ID) { } else if (uiQualityId > BASE_QUALITY_ID) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "MGS not supported.\n"); WelsLog (pLogCtx, WELS_LOG_WARNING, "MGS not supported.");
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_MGS); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_MGS);
} else { } else {
pSliceHeadExt->uiRefLayerDqId = (uint8_t) - 1; pSliceHeadExt->uiRefLayerDqId = (uint8_t) - 1;
@@ -863,7 +863,7 @@ int32_t ParseSliceHeaderSyntaxs (PWelsDecoderContext pCtx, PBitStringAux pBs, co
WELS_READ_VERIFY (BsGetBits (pBs, 4, &uiCode)); //scan_idx_end WELS_READ_VERIFY (BsGetBits (pBs, 4, &uiCode)); //scan_idx_end
pSliceHeadExt->uiScanIdxEnd = uiCode; pSliceHeadExt->uiScanIdxEnd = uiCode;
if (pSliceHeadExt->uiScanIdxStart != 0 || pSliceHeadExt->uiScanIdxEnd != 15) { if (pSliceHeadExt->uiScanIdxStart != 0 || pSliceHeadExt->uiScanIdxEnd != 15) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "uiScanIdxStart (%d) != 0 and uiScanIdxEnd (%d) !=15 not supported here\n", WelsLog (pLogCtx, WELS_LOG_WARNING, "uiScanIdxStart (%d) != 0 and uiScanIdxEnd (%d) !=15 not supported here",
pSliceHeadExt->uiScanIdxStart, pSliceHeadExt->uiScanIdxEnd); pSliceHeadExt->uiScanIdxStart, pSliceHeadExt->uiScanIdxEnd);
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_MGS); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_UNSUPPORTED_MGS);
} }
@@ -957,7 +957,7 @@ int32_t UpdateAccessUnit (PWelsDecoderContext pCtx) {
if (uiActualIdx == if (uiActualIdx ==
pCurAu->uiActualUnitsNum) { // no found IDR nal within incoming AU, need exit to avoid mosaic issue, 11/19/2009 pCurAu->uiActualUnitsNum) { // no found IDR nal within incoming AU, need exit to avoid mosaic issue, 11/19/2009
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING,
"UpdateAccessUnit():::::Key frame lost.....CAN NOT find IDR from current AU.\n"); "UpdateAccessUnit():::::Key frame lost.....CAN NOT find IDR from current AU.");
pCtx->iErrorCode |= dsRefLost; pCtx->iErrorCode |= dsRefLost;
if (pCtx->eErrorConMethod == ERROR_CON_DISABLE) { if (pCtx->eErrorConMethod == ERROR_CON_DISABLE) {
#ifdef LONG_TERM_REF #ifdef LONG_TERM_REF
@@ -1668,7 +1668,7 @@ int32_t ConstructAccessUnit (PWelsDecoderContext pCtx, uint8_t** ppDst, SBufferI
if (pCtx->bNewSeqBegin) if (pCtx->bNewSeqBegin)
ResetActiveSPSForEachLayer (pCtx); ResetActiveSPSForEachLayer (pCtx);
if (ERR_NONE != iErr) { if (ERR_NONE != iErr) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, "returned error from decoding:[0x%x]\n", iErr); WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, "returned error from decoding:[0x%x]", iErr);
return iErr; return iErr;
} }
@@ -1804,7 +1804,7 @@ int32_t DecodeCurrentAccessUnit (PWelsDecoderContext pCtx, uint8_t** ppDst, SBuf
if (NULL == pCtx->pDec) { if (NULL == pCtx->pDec) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR,
"DecodeCurrentAccessUnit()::::::PrefetchPic ERROR, pSps->iNumRefFrames:%d.\n", "DecodeCurrentAccessUnit()::::::PrefetchPic ERROR, pSps->iNumRefFrames:%d.",
pCtx->pSps->iNumRefFrames); pCtx->pSps->iNumRefFrames);
pCtx->iErrorCode |= dsOutOfMemory; pCtx->iErrorCode |= dsOutOfMemory;
return ERR_INFO_REF_COUNT_OVERFLOW; return ERR_INFO_REF_COUNT_OVERFLOW;
@@ -1857,7 +1857,7 @@ int32_t DecodeCurrentAccessUnit (PWelsDecoderContext pCtx, uint8_t** ppDst, SBuf
pCtx->pFmo = &pCtx->sFmoList[iPpsId]; pCtx->pFmo = &pCtx->sFmoList[iPpsId];
if (!FmoParamUpdate (pCtx->pFmo, pLayerInfo.pSps, pLayerInfo.pPps, &pCtx->iActiveFmoNum)) { if (!FmoParamUpdate (pCtx->pFmo, pLayerInfo.pSps, pLayerInfo.pPps, &pCtx->iActiveFmoNum)) {
pCtx->iErrorCode |= dsBitstreamError; pCtx->iErrorCode |= dsBitstreamError;
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "DecodeCurrentAccessUnit(), FmoParamUpdate failed, eSliceType: %d.\n", WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "DecodeCurrentAccessUnit(), FmoParamUpdate failed, eSliceType: %d.",
pSh->eSliceType); pSh->eSliceType);
return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_FMO_INIT_FAIL); return GENERATE_ERROR_NO (ERR_LEVEL_SLICE_HEADER, ERR_INFO_FMO_INIT_FAIL);
} }
@@ -1883,7 +1883,7 @@ int32_t DecodeCurrentAccessUnit (PWelsDecoderContext pCtx, uint8_t** ppDst, SBuf
pSh->iFrameNum != pCtx->iPrevFrameNum && pSh->iFrameNum != pCtx->iPrevFrameNum &&
pSh->iFrameNum != ((pCtx->iPrevFrameNum + 1) & ((1 << dq_cur->sLayerInfo.pSps->uiLog2MaxFrameNum) - 1))) { pSh->iFrameNum != ((pCtx->iPrevFrameNum + 1) & ((1 << dq_cur->sLayerInfo.pSps->uiLog2MaxFrameNum) - 1))) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING,
"referencing pictures lost due frame gaps exist, prev_frame_num: %d, curr_frame_num: %d\n", pCtx->iPrevFrameNum, "referencing pictures lost due frame gaps exist, prev_frame_num: %d, curr_frame_num: %d", pCtx->iPrevFrameNum,
pSh->iFrameNum); pSh->iFrameNum);
pCtx->iErrorCode |= dsRefLost; pCtx->iErrorCode |= dsRefLost;
@@ -1904,7 +1904,7 @@ int32_t DecodeCurrentAccessUnit (PWelsDecoderContext pCtx, uint8_t** ppDst, SBuf
if (iRet) { if (iRet) {
HandleReferenceLost (pCtx, pNalCur); HandleReferenceLost (pCtx, pNalCur);
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING,
"reference picture introduced by this frame is lost during transmission! uiTId: %d\n", "reference picture introduced by this frame is lost during transmission! uiTId: %d",
pNalCur->sNalHeaderExt.uiTemporalId); pNalCur->sNalHeaderExt.uiTemporalId);
if (pCtx->eErrorConMethod == ERROR_CON_DISABLE) { if (pCtx->eErrorConMethod == ERROR_CON_DISABLE) {
return iRet; return iRet;
@@ -1917,7 +1917,7 @@ int32_t DecodeCurrentAccessUnit (PWelsDecoderContext pCtx, uint8_t** ppDst, SBuf
//Output good store_base reconstruction when enhancement quality layer occurred error for MGS key picture case //Output good store_base reconstruction when enhancement quality layer occurred error for MGS key picture case
if (iRet != ERR_NONE) { if (iRet != ERR_NONE) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING,
"DecodeCurrentAccessUnit() failed (%d) in frame: %d uiDId: %d uiQId: %d\n", "DecodeCurrentAccessUnit() failed (%d) in frame: %d uiDId: %d uiQId: %d",
iRet, pSh->iFrameNum, iCurrIdD, iCurrIdQ); iRet, pSh->iFrameNum, iCurrIdD, iCurrIdQ);
HandleReferenceLostL0 (pCtx, pNalCur); HandleReferenceLostL0 (pCtx, pNalCur);
if (pCtx->eErrorConMethod == ERROR_CON_DISABLE) { if (pCtx->eErrorConMethod == ERROR_CON_DISABLE) {

18
codec/decoder/core/src/manage_dec_ref.cpp
View File

@@ -125,7 +125,7 @@ int32_t WelsInitRefList (PWelsDecoderContext pCtx, int32_t iPoc) {
pCtx->sExpandPicFunc.pfExpandLumaPicture, pCtx->sExpandPicFunc.pfExpandChromaPicture); pCtx->sExpandPicFunc.pfExpandLumaPicture, pCtx->sExpandPicFunc.pfExpandChromaPicture);
AddShortTermToList (&pCtx->sRefPic, pRef); AddShortTermToList (&pCtx->sRefPic, pRef);
} else { } else {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, "WelsInitRefList()::PrefetchPic for EC errors.\n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, "WelsInitRefList()::PrefetchPic for EC errors.");
pCtx->iErrorCode |= dsOutOfMemory; pCtx->iErrorCode |= dsOutOfMemory;
return ERR_INFO_REF_COUNT_OVERFLOW; return ERR_INFO_REF_COUNT_OVERFLOW;
} }
@@ -189,7 +189,7 @@ int32_t WelsReorderRefList (PWelsDecoderContext pCtx) {
if (ppRefList[i]->iFrameNum == iPredFrameNum && !ppRefList[i]->bIsLongRef) { if (ppRefList[i]->iFrameNum == iPredFrameNum && !ppRefList[i]->bIsLongRef) {
if ((pNalHeaderExt->uiQualityId == ppRefList[i]->uiQualityId) if ((pNalHeaderExt->uiQualityId == ppRefList[i]->uiQualityId)
&& (pSliceHeader->iSpsId != ppRefList[i]->iSpsId)) { //check; && (pSliceHeader->iSpsId != ppRefList[i]->iSpsId)) { //check;
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "WelsReorderRefList()::::BASE LAYER::::iSpsId:%d, ref_sps_id:%d\n", WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "WelsReorderRefList()::::BASE LAYER::::iSpsId:%d, ref_sps_id:%d",
pSliceHeader->iSpsId, ppRefList[i]->iSpsId); pSliceHeader->iSpsId, ppRefList[i]->iSpsId);
pCtx->iErrorCode = dsNoParamSets; //cross-IDR reference frame selection, SHOULD request IDR.-- pCtx->iErrorCode = dsNoParamSets; //cross-IDR reference frame selection, SHOULD request IDR.--
return ERR_INFO_REFERENCE_PIC_LOST; return ERR_INFO_REFERENCE_PIC_LOST;
@@ -206,7 +206,7 @@ int32_t WelsReorderRefList (PWelsDecoderContext pCtx) {
pRefPicListReorderSyn->sReorderingSyn[LIST_0][iReorderingIndex].uiLongTermPicNum) { pRefPicListReorderSyn->sReorderingSyn[LIST_0][iReorderingIndex].uiLongTermPicNum) {
if ((pNalHeaderExt->uiQualityId == ppRefList[i]->uiQualityId) if ((pNalHeaderExt->uiQualityId == ppRefList[i]->uiQualityId)
&& (pSliceHeader->iSpsId != ppRefList[i]->iSpsId)) { //check; && (pSliceHeader->iSpsId != ppRefList[i]->iSpsId)) { //check;
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "WelsReorderRefList()::::BASE LAYER::::iSpsId:%d, ref_sps_id:%d\n", WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "WelsReorderRefList()::::BASE LAYER::::iSpsId:%d, ref_sps_id:%d",
pSliceHeader->iSpsId, ppRefList[i]->iSpsId); pSliceHeader->iSpsId, ppRefList[i]->iSpsId);
pCtx->iErrorCode = dsNoParamSets; //cross-IDR reference frame selection, SHOULD request IDR.-- pCtx->iErrorCode = dsNoParamSets; //cross-IDR reference frame selection, SHOULD request IDR.--
return ERR_INFO_REFERENCE_PIC_LOST; return ERR_INFO_REFERENCE_PIC_LOST;
@@ -330,13 +330,13 @@ static int32_t MMCOProcess (PWelsDecoderContext pCtx, uint32_t uiMmcoType,
case MMCO_SHORT2UNUSED: case MMCO_SHORT2UNUSED:
pPic = WelsDelShortFromListSetUnref (pRefPic, iShortFrameNum); pPic = WelsDelShortFromListSetUnref (pRefPic, iShortFrameNum);
if (pPic == NULL) { if (pPic == NULL) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "MMCO_SHORT2UNUSED: delete a empty entry from short term list\n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "MMCO_SHORT2UNUSED: delete a empty entry from short term list");
} }
break; break;
case MMCO_LONG2UNUSED: case MMCO_LONG2UNUSED:
pPic = WelsDelLongFromListSetUnref (pRefPic, uiLongTermPicNum); pPic = WelsDelLongFromListSetUnref (pRefPic, uiLongTermPicNum);
if (pPic == NULL) { if (pPic == NULL) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "MMCO_LONG2UNUSED: delete a empty entry from long term list\n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "MMCO_LONG2UNUSED: delete a empty entry from long term list");
} }
break; break;
case MMCO_SHORT2LONG: case MMCO_SHORT2LONG:
@@ -345,14 +345,14 @@ static int32_t MMCOProcess (PWelsDecoderContext pCtx, uint32_t uiMmcoType,
} }
pPic = WelsDelShortFromList (pRefPic, iShortFrameNum); pPic = WelsDelShortFromList (pRefPic, iShortFrameNum);
if (pPic == NULL) { if (pPic == NULL) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "MMCO_LONG2LONG: delete a empty entry from short term list\n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "MMCO_LONG2LONG: delete a empty entry from short term list");
break; break;
} }
WelsDelLongFromListSetUnref (pRefPic, iLongTermFrameIdx); WelsDelLongFromListSetUnref (pRefPic, iLongTermFrameIdx);
#ifdef LONG_TERM_REF #ifdef LONG_TERM_REF
pCtx->bCurAuContainLtrMarkSeFlag = true; pCtx->bCurAuContainLtrMarkSeFlag = true;
pCtx->iFrameNumOfAuMarkedLtr = iShortFrameNum; pCtx->iFrameNumOfAuMarkedLtr = iShortFrameNum;
WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, "ex_mark_avc():::MMCO_SHORT2LONG:::LTR marking....iFrameNum: %d\n", WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, "ex_mark_avc():::MMCO_SHORT2LONG:::LTR marking....iFrameNum: %d",
pCtx->iFrameNumOfAuMarkedLtr); pCtx->iFrameNumOfAuMarkedLtr);
#endif #endif
@@ -381,7 +381,7 @@ static int32_t MMCOProcess (PWelsDecoderContext pCtx, uint32_t uiMmcoType,
#ifdef LONG_TERM_REF #ifdef LONG_TERM_REF
pCtx->bCurAuContainLtrMarkSeFlag = true; pCtx->bCurAuContainLtrMarkSeFlag = true;
pCtx->iFrameNumOfAuMarkedLtr = pCtx->iFrameNum; pCtx->iFrameNumOfAuMarkedLtr = pCtx->iFrameNum;
WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, "ex_mark_avc():::MMCO_LONG:::LTR marking....iFrameNum: %d\n", WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, "ex_mark_avc():::MMCO_LONG:::LTR marking....iFrameNum: %d",
pCtx->iFrameNum); pCtx->iFrameNum);
#endif #endif
iRet = AddLongTermToList (pRefPic, pCtx->pDec, iLongTermFrameIdx); iRet = AddLongTermToList (pRefPic, pCtx->pDec, iLongTermFrameIdx);
@@ -567,7 +567,7 @@ static int32_t RemainOneBufferInDpbForEC (PWelsDecoderContext pCtx) {
} }
if (pRefPic->uiShortRefCount[0] + pRefPic->uiLongRefCount[0] >= if (pRefPic->uiShortRefCount[0] + pRefPic->uiLongRefCount[0] >=
pCtx->pSps->iNumRefFrames) { //fail to remain one empty buffer in DPB pCtx->pSps->iNumRefFrames) { //fail to remain one empty buffer in DPB
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "RemainOneBufferInDpbForEC(): empty one DPB failed for EC!\n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "RemainOneBufferInDpbForEC(): empty one DPB failed for EC!");
iRet = ERR_INFO_REF_COUNT_OVERFLOW; iRet = ERR_INFO_REF_COUNT_OVERFLOW;
} }

8
codec/decoder/core/src/parse_mb_syn_cavlc.cpp
View File

@@ -1011,7 +1011,7 @@ int32_t ParseInterInfo (PWelsDecoderContext pCtx, int16_t iMvArray[LIST_A][30][M
} }
} }
} else { } else {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "inter parse: iMotionPredFlag = 1 not supported. \n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "inter parse: iMotionPredFlag = 1 not supported. ");
return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_UNSUPPORTED_ILP); return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_UNSUPPORTED_ILP);
} }
PredMv (iMvArray, iRefIdxArray, 0, 4, iRefIdx, iMv); PredMv (iMvArray, iRefIdxArray, 0, 4, iRefIdx, iMv);
@@ -1035,7 +1035,7 @@ int32_t ParseInterInfo (PWelsDecoderContext pCtx, int16_t iMvArray[LIST_A][30][M
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
if (iMotionPredFlag[i]) { if (iMotionPredFlag[i]) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "inter parse: iMotionPredFlag = 1 not supported. \n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "inter parse: iMotionPredFlag = 1 not supported. ");
return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_UNSUPPORTED_ILP); return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_UNSUPPORTED_ILP);
} }
WELS_READ_VERIFY (BsGetTe0 (pBs, iRefCount[0], &uiCode)); //ref_idx_l0[ mbPartIdx ] WELS_READ_VERIFY (BsGetTe0 (pBs, iRefCount[0], &uiCode)); //ref_idx_l0[ mbPartIdx ]
@@ -1083,7 +1083,7 @@ int32_t ParseInterInfo (PWelsDecoderContext pCtx, int16_t iMvArray[LIST_A][30][M
} }
} }
} else { } else {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "inter parse: iMotionPredFlag = 1 not supported. \n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "inter parse: iMotionPredFlag = 1 not supported. ");
return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_UNSUPPORTED_ILP); return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_UNSUPPORTED_ILP);
} }
@@ -1152,7 +1152,7 @@ int32_t ParseInterInfo (PWelsDecoderContext pCtx, int16_t iMvArray[LIST_A][30][M
pCurDqLayer->pRefIndex[0][iMbXy][uiScan4Idx ] = pCurDqLayer->pRefIndex[0][iMbXy][uiScan4Idx + 1] = pCurDqLayer->pRefIndex[0][iMbXy][uiScan4Idx ] = pCurDqLayer->pRefIndex[0][iMbXy][uiScan4Idx + 1] =
pCurDqLayer->pRefIndex[0][iMbXy][uiScan4Idx + 4] = pCurDqLayer->pRefIndex[0][iMbXy][uiScan4Idx + 5] = iRefIdx[i]; pCurDqLayer->pRefIndex[0][iMbXy][uiScan4Idx + 4] = pCurDqLayer->pRefIndex[0][iMbXy][uiScan4Idx + 5] = iRefIdx[i];
} else { } else {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "inter parse: iMotionPredFlag = 1 not supported. \n"); WelsLog (& (pCtx->sLogCtx), WELS_LOG_WARNING, "inter parse: iMotionPredFlag = 1 not supported. ");
return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_UNSUPPORTED_ILP); return GENERATE_ERROR_NO (ERR_LEVEL_MB_DATA, ERR_INFO_UNSUPPORTED_ILP);
} }
} }

4
codec/encoder/core/src/au_set.cpp
View File

@@ -83,14 +83,14 @@ int32_t WelsCheckRefFrameLimitation (SLogContext* pLogCtx, SWelsSvcCodingParam*
uint32_t uiPicInMBs = ((pSpatialLayer->iVideoHeight + 15) >> 4) * ((pSpatialLayer->iVideoWidth + 15) >> 4); uint32_t uiPicInMBs = ((pSpatialLayer->iVideoHeight + 15) >> 4) * ((pSpatialLayer->iVideoWidth + 15) >> 4);
if (pSpatialLayer->uiLevelIdc == LEVEL_UNKNOWN) { if (pSpatialLayer->uiLevelIdc == LEVEL_UNKNOWN) {
pSpatialLayer->uiLevelIdc = LEVEL_5_0; pSpatialLayer->uiLevelIdc = LEVEL_5_0;
WelsLog (pLogCtx, WELS_LOG_WARNING, "change level to level5.0\n"); WelsLog (pLogCtx, WELS_LOG_WARNING, "change level to level5.0");
} }
iRefFrame = g_ksLevelLimits[pSpatialLayer->uiLevelIdc - 1].uiMaxDPBMbs / uiPicInMBs; iRefFrame = g_ksLevelLimits[pSpatialLayer->uiLevelIdc - 1].uiMaxDPBMbs / uiPicInMBs;
if (iRefFrame < pParam->iMaxNumRefFrame) if (iRefFrame < pParam->iMaxNumRefFrame)
pParam->iMaxNumRefFrame = iRefFrame; pParam->iMaxNumRefFrame = iRefFrame;
if (pParam->iMaxNumRefFrame < 1) { if (pParam->iMaxNumRefFrame < 1) {
pParam->iMaxNumRefFrame = 1; pParam->iMaxNumRefFrame = 1;
WelsLog (pLogCtx, WELS_LOG_ERROR, "error Level setting (%d)\n", pSpatialLayer->uiLevelIdc); WelsLog (pLogCtx, WELS_LOG_ERROR, "error Level setting (%d)", pSpatialLayer->uiLevelIdc);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
} }

130
codec/encoder/core/src/encoder_ext.cpp
View File

@@ -82,25 +82,25 @@ int32_t ParamValidation (SLogContext* pLogCtx, SWelsSvcCodingParam* pCfg) {
assert (pCfg != NULL); assert (pCfg != NULL);
if ((pCfg->iUsageType != CAMERA_VIDEO_REAL_TIME) && (pCfg->iUsageType != SCREEN_CONTENT_REAL_TIME)) { if ((pCfg->iUsageType != CAMERA_VIDEO_REAL_TIME) && (pCfg->iUsageType != SCREEN_CONTENT_REAL_TIME)) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidation(),Invalid usage type = %d\n", pCfg->iUsageType); WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidation(),Invalid usage type = %d", pCfg->iUsageType);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if (pCfg->iUsageType == SCREEN_CONTENT_REAL_TIME) { if (pCfg->iUsageType == SCREEN_CONTENT_REAL_TIME) {
if (pCfg->iSpatialLayerNum > 1) { if (pCfg->iSpatialLayerNum > 1) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidation(),Invalid the number of Spatial layer(%d)for screen content\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidation(),Invalid the number of Spatial layer(%d)for screen content",
pCfg->iSpatialLayerNum); pCfg->iSpatialLayerNum);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if (pCfg->bEnableAdaptiveQuant) { if (pCfg->bEnableAdaptiveQuant) {
WelsLog (pLogCtx, WELS_LOG_WARNING, WelsLog (pLogCtx, WELS_LOG_WARNING,
"ParamValidation(), AdaptiveQuant(%d) is not supported yet for screen content, auto turned off\n", "ParamValidation(), AdaptiveQuant(%d) is not supported yet for screen content, auto turned off",
pCfg->bEnableAdaptiveQuant); pCfg->bEnableAdaptiveQuant);
pCfg->bEnableAdaptiveQuant = false; pCfg->bEnableAdaptiveQuant = false;
} }
if (pCfg->bEnableSceneChangeDetect == false) { if (pCfg->bEnableSceneChangeDetect == false) {
pCfg->bEnableSceneChangeDetect = true; pCfg->bEnableSceneChangeDetect = true;
WelsLog (pLogCtx, WELS_LOG_WARNING, WelsLog (pLogCtx, WELS_LOG_WARNING,
"ParamValidation(), screen change detection should be turned on,change bEnableSceneChangeDetect as true\n"); "ParamValidation(), screen change detection should be turned on,change bEnableSceneChangeDetect as true");
} }
} }
@@ -111,7 +111,7 @@ int32_t ParamValidation (SLogContext* pLogCtx, SWelsSvcCodingParam* pCfg) {
SSpatialLayerConfig* fDlp = &pCfg->sSpatialLayers[i]; SSpatialLayerConfig* fDlp = &pCfg->sSpatialLayers[i];
if ((fDlp->iVideoWidth > iFinalWidth) || (fDlp->iVideoHeight > iFinalHeight)) { if ((fDlp->iVideoWidth > iFinalWidth) || (fDlp->iVideoHeight > iFinalHeight)) {
WelsLog (pLogCtx, WELS_LOG_ERROR, WelsLog (pLogCtx, WELS_LOG_ERROR,
"ParamValidation,Invalid resolution layer(%d) resolution(%d x %d) shoudl be less than the highest spatial layer resolution(%d x %d)\n ", "ParamValidation,Invalid resolution layer(%d) resolution(%d x %d) shoudl be less than the highest spatial layer resolution(%d x %d) ",
i, fDlp->iVideoWidth, fDlp->iVideoHeight, iFinalWidth, iFinalHeight); i, fDlp->iVideoWidth, fDlp->iVideoHeight, iFinalWidth, iFinalHeight);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
@@ -123,13 +123,13 @@ int32_t ParamValidation (SLogContext* pLogCtx, SWelsSvcCodingParam* pCfg) {
&& fDlp->fInputFrameRate <= fEpsn) && fDlp->fInputFrameRate <= fEpsn)
|| (fDlp->fOutputFrameRate >= -fEpsn && fDlp->fOutputFrameRate <= fEpsn)) { || (fDlp->fOutputFrameRate >= -fEpsn && fDlp->fOutputFrameRate <= fEpsn)) {
WelsLog (pLogCtx, WELS_LOG_ERROR, WelsLog (pLogCtx, WELS_LOG_ERROR,
"Invalid settings in input frame rate(%.6f) or output frame rate(%.6f) of layer #%d config file..\n", "Invalid settings in input frame rate(%.6f) or output frame rate(%.6f) of layer #%d config file..",
fDlp->fInputFrameRate, fDlp->fOutputFrameRate, i); fDlp->fInputFrameRate, fDlp->fOutputFrameRate, i);
return ENC_RETURN_INVALIDINPUT; return ENC_RETURN_INVALIDINPUT;
} }
if (UINT_MAX == GetLogFactor (fDlp->fOutputFrameRate, fDlp->fInputFrameRate)) { if (UINT_MAX == GetLogFactor (fDlp->fOutputFrameRate, fDlp->fInputFrameRate)) {
WelsLog (pLogCtx, WELS_LOG_ERROR, WelsLog (pLogCtx, WELS_LOG_ERROR,
"Invalid settings in input frame rate(%.6f) and output frame rate(%.6f) of layer #%d config file: iResult of output frame rate divided by input frame rate should be power of 2(i.e,in/pOut=2^n)..\n", "Invalid settings in input frame rate(%.6f) and output frame rate(%.6f) of layer #%d config file: iResult of output frame rate divided by input frame rate should be power of 2(i.e,in/pOut=2^n)..",
fDlp->fInputFrameRate, fDlp->fOutputFrameRate, i); fDlp->fInputFrameRate, fDlp->fOutputFrameRate, i);
return ENC_RETURN_INVALIDINPUT; return ENC_RETURN_INVALIDINPUT;
} }
@@ -150,28 +150,28 @@ int32_t ParamValidation (SLogContext* pLogCtx, SWelsSvcCodingParam* pCfg) {
if ((pCfg->iRCMode != RC_OFF_MODE) && (pCfg->iRCMode != RC_QUALITY_MODE) && (pCfg->iRCMode != RC_BUFFERBASED_MODE) if ((pCfg->iRCMode != RC_OFF_MODE) && (pCfg->iRCMode != RC_QUALITY_MODE) && (pCfg->iRCMode != RC_BUFFERBASED_MODE)
&& (pCfg->iRCMode != RC_BITRATE_MODE) && (pCfg->iRCMode != RC_BITRATE_MODE)
&& (pCfg->iRCMode != RC_LOW_BW_MODE)) { && (pCfg->iRCMode != RC_LOW_BW_MODE)) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidation(),Invalid iRCMode = %d\n", pCfg->iRCMode); WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidation(),Invalid iRCMode = %d", pCfg->iRCMode);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
//bitrate setting validation //bitrate setting validation
if (pCfg->iRCMode != RC_OFF_MODE) { if (pCfg->iRCMode != RC_OFF_MODE) {
int32_t iTotalBitrate = 0; int32_t iTotalBitrate = 0;
if (pCfg->iTargetBitrate <= 0) { if (pCfg->iTargetBitrate <= 0) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "Invalid bitrate settings in total configure, bitrate= %d\n", pCfg->iTargetBitrate); WelsLog (pLogCtx, WELS_LOG_ERROR, "Invalid bitrate settings in total configure, bitrate= %d", pCfg->iTargetBitrate);
return ENC_RETURN_INVALIDINPUT; return ENC_RETURN_INVALIDINPUT;
} }
for (i = 0; i < pCfg->iSpatialLayerNum; ++ i) { for (i = 0; i < pCfg->iSpatialLayerNum; ++ i) {
SSpatialLayerConfig* pSpatialLayer = &pCfg->sSpatialLayers[i]; SSpatialLayerConfig* pSpatialLayer = &pCfg->sSpatialLayers[i];
iTotalBitrate += pSpatialLayer->iSpatialBitrate; iTotalBitrate += pSpatialLayer->iSpatialBitrate;
if (pSpatialLayer->iSpatialBitrate <= 0) { if (pSpatialLayer->iSpatialBitrate <= 0) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "Invalid bitrate settings in layer %d, bitrate= %d\n", i, WelsLog (pLogCtx, WELS_LOG_ERROR, "Invalid bitrate settings in layer %d, bitrate= %d", i,
pSpatialLayer->iSpatialBitrate); pSpatialLayer->iSpatialBitrate);
return ENC_RETURN_INVALIDINPUT; return ENC_RETURN_INVALIDINPUT;
} }
} }
if (iTotalBitrate > pCfg->iTargetBitrate) { if (iTotalBitrate > pCfg->iTargetBitrate) {
WelsLog (pLogCtx, WELS_LOG_ERROR, WelsLog (pLogCtx, WELS_LOG_ERROR,
"Invalid settings in bitrate. the sum of each layer bitrate(%d) is larger than total bitrate setting(%d)\n", "Invalid settings in bitrate. the sum of each layer bitrate(%d) is larger than total bitrate setting(%d)",
iTotalBitrate, pCfg->iTargetBitrate); iTotalBitrate, pCfg->iTargetBitrate);
return ENC_RETURN_INVALIDINPUT; return ENC_RETURN_INVALIDINPUT;
} }
@@ -190,23 +190,23 @@ int32_t ParamValidationExt (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPa
return ENC_RETURN_INVALIDINPUT; return ENC_RETURN_INVALIDINPUT;
if ((pCodingParam->iUsageType != CAMERA_VIDEO_REAL_TIME) && (pCodingParam->iUsageType != SCREEN_CONTENT_REAL_TIME)) { if ((pCodingParam->iUsageType != CAMERA_VIDEO_REAL_TIME) && (pCodingParam->iUsageType != SCREEN_CONTENT_REAL_TIME)) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(),Invalid usage type = %d\n", pCodingParam->iUsageType); WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(),Invalid usage type = %d", pCodingParam->iUsageType);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if (pCodingParam->iSpatialLayerNum < 1 || pCodingParam->iSpatialLayerNum > MAX_DEPENDENCY_LAYER) { if (pCodingParam->iSpatialLayerNum < 1 || pCodingParam->iSpatialLayerNum > MAX_DEPENDENCY_LAYER) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), monitor invalid pCodingParam->iSpatialLayerNum: %d!\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), monitor invalid pCodingParam->iSpatialLayerNum: %d!",
pCodingParam->iSpatialLayerNum); pCodingParam->iSpatialLayerNum);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if (pCodingParam->iTemporalLayerNum < 1 || pCodingParam->iTemporalLayerNum > MAX_TEMPORAL_LEVEL) { if (pCodingParam->iTemporalLayerNum < 1 || pCodingParam->iTemporalLayerNum > MAX_TEMPORAL_LEVEL) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), monitor invalid pCodingParam->iTemporalLayerNum: %d!\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), monitor invalid pCodingParam->iTemporalLayerNum: %d!",
pCodingParam->iTemporalLayerNum); pCodingParam->iTemporalLayerNum);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if (pCodingParam->uiGopSize < 1 || pCodingParam->uiGopSize > MAX_GOP_SIZE) { if (pCodingParam->uiGopSize < 1 || pCodingParam->uiGopSize > MAX_GOP_SIZE) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), monitor invalid pCodingParam->uiGopSize: %d!\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), monitor invalid pCodingParam->uiGopSize: %d!",
pCodingParam->uiGopSize); pCodingParam->uiGopSize);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
@@ -214,14 +214,14 @@ int32_t ParamValidationExt (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPa
if (pCodingParam->uiIntraPeriod && pCodingParam->uiIntraPeriod < pCodingParam->uiGopSize) { if (pCodingParam->uiIntraPeriod && pCodingParam->uiIntraPeriod < pCodingParam->uiGopSize) {
WelsLog (pLogCtx, WELS_LOG_ERROR, WelsLog (pLogCtx, WELS_LOG_ERROR,
"ParamValidationExt(), uiIntraPeriod(%d) should be not less than that of uiGopSize(%d) or -1 specified!\n", "ParamValidationExt(), uiIntraPeriod(%d) should be not less than that of uiGopSize(%d) or -1 specified!",
pCodingParam->uiIntraPeriod, pCodingParam->uiGopSize); pCodingParam->uiIntraPeriod, pCodingParam->uiGopSize);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if (pCodingParam->uiIntraPeriod && (pCodingParam->uiIntraPeriod & (pCodingParam->uiGopSize - 1)) != 0) { if (pCodingParam->uiIntraPeriod && (pCodingParam->uiIntraPeriod & (pCodingParam->uiGopSize - 1)) != 0) {
WelsLog (pLogCtx, WELS_LOG_ERROR, WelsLog (pLogCtx, WELS_LOG_ERROR,
"ParamValidationExt(), uiIntraPeriod(%d) should be multiple of uiGopSize(%d) or -1 specified!\n", "ParamValidationExt(), uiIntraPeriod(%d) should be multiple of uiGopSize(%d) or -1 specified!",
pCodingParam->uiIntraPeriod, pCodingParam->uiGopSize); pCodingParam->uiIntraPeriod, pCodingParam->uiGopSize);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
@@ -249,24 +249,24 @@ int32_t ParamValidationExt (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPa
uint32_t iMaxSliceNum = MAX_SLICES_NUM; uint32_t iMaxSliceNum = MAX_SLICES_NUM;
if ((kiPicWidth <= 0) || (kiPicHeight <= 0) || (kiPicWidth > MAX_WIDTH) || (kiPicHeight > MAX_HEIGHT)) { if ((kiPicWidth <= 0) || (kiPicHeight <= 0) || (kiPicWidth > MAX_WIDTH) || (kiPicHeight > MAX_HEIGHT)) {
WelsLog (pLogCtx, WELS_LOG_ERROR, WelsLog (pLogCtx, WELS_LOG_ERROR,
"ParamValidationExt(),width(1-%d),height(1-%d)invalid %d x %d in dependency layer settings!\n", MAX_WIDTH, MAX_HEIGHT, "ParamValidationExt(),width(1-%d),height(1-%d)invalid %d x %d in dependency layer settings!", MAX_WIDTH, MAX_HEIGHT,
kiPicWidth, kiPicHeight); kiPicWidth, kiPicHeight);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if ((kiPicWidth & 0x0F) != 0 || (kiPicHeight & 0x0F) != 0) { if ((kiPicWidth & 0x0F) != 0 || (kiPicHeight & 0x0F) != 0) {
WelsLog (pLogCtx, WELS_LOG_ERROR, WelsLog (pLogCtx, WELS_LOG_ERROR,
"ParamValidationExt(), in layer #%d iWidth x iHeight(%d x %d) both should be multiple of 16, can not support with arbitrary size currently!\n", "ParamValidationExt(), in layer #%d iWidth x iHeight(%d x %d) both should be multiple of 16, can not support with arbitrary size currently!",
i, kiPicWidth, kiPicHeight); i, kiPicWidth, kiPicHeight);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if (pSpatialLayer->sSliceCfg.uiSliceMode >= SM_RESERVED) { if (pSpatialLayer->sSliceCfg.uiSliceMode >= SM_RESERVED) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMode (%d) settings!\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMode (%d) settings!",
pSpatialLayer->sSliceCfg.uiSliceMode); pSpatialLayer->sSliceCfg.uiSliceMode);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if ((pCodingParam->uiMaxNalSize != 0) && (pSpatialLayer->sSliceCfg.uiSliceMode != SM_DYN_SLICE)) { if ((pCodingParam->uiMaxNalSize != 0) && (pSpatialLayer->sSliceCfg.uiSliceMode != SM_DYN_SLICE)) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMode (%d) settings!,MaxNalSize = %d\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMode (%d) settings!,MaxNalSize = %d",
pSpatialLayer->sSliceCfg.uiSliceMode, pCodingParam->uiMaxNalSize); pSpatialLayer->sSliceCfg.uiSliceMode, pCodingParam->uiMaxNalSize);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
@@ -292,13 +292,13 @@ int32_t ParamValidationExt (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPa
iMaxSliceNum = MAX_SLICES_NUM; iMaxSliceNum = MAX_SLICES_NUM;
if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum <= 0 if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum <= 0
|| pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum > iMaxSliceNum) { || pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum > iMaxSliceNum) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) settings!\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) settings!",
pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum); pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum == 1) { if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum == 1) {
WelsLog (pLogCtx, WELS_LOG_DEBUG, WelsLog (pLogCtx, WELS_LOG_DEBUG,
"ParamValidationExt(), uiSliceNum(%d) you set for SM_FIXEDSLCNUM_SLICE, now turn to SM_SINGLE_SLICE type!\n", "ParamValidationExt(), uiSliceNum(%d) you set for SM_FIXEDSLCNUM_SLICE, now turn to SM_SINGLE_SLICE type!",
pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum); pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum);
pSpatialLayer->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE; pSpatialLayer->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
break; break;
@@ -312,7 +312,7 @@ int32_t ParamValidationExt (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPa
} else if (!CheckFixedSliceNumMultiSliceSetting (iMbNumInFrame, } else if (!CheckFixedSliceNumMultiSliceSetting (iMbNumInFrame,
&pSpatialLayer->sSliceCfg.sSliceArgument)) { // verify interleave mode settings &pSpatialLayer->sSliceCfg.sSliceArgument)) { // verify interleave mode settings
//check uiSliceMbNum with current uiSliceNum //check uiSliceMbNum with current uiSliceNum
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!",
pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0]); pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0]);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
@@ -336,31 +336,31 @@ int32_t ParamValidationExt (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPa
iMbNumInFrame = iMbWidth * iMbHeight; iMbNumInFrame = iMbWidth * iMbHeight;
iMaxSliceNum = MAX_SLICES_NUM; iMaxSliceNum = MAX_SLICES_NUM;
if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0] <= 0) { if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0] <= 0) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!",
pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0]); pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0]);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if (!CheckRasterMultiSliceSetting (iMbNumInFrame, if (!CheckRasterMultiSliceSetting (iMbNumInFrame,
&pSpatialLayer->sSliceCfg.sSliceArgument)) { // verify interleave mode settings &pSpatialLayer->sSliceCfg.sSliceArgument)) { // verify interleave mode settings
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!",
pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0]); pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0]);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum <= 0 if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum <= 0
|| pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum > iMaxSliceNum) { // verify interleave mode settings || pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum > iMaxSliceNum) { // verify interleave mode settings
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) in SM_RASTER_SLICE settings!\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) in SM_RASTER_SLICE settings!",
pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum); pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum == 1) { if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum == 1) {
WelsLog (pLogCtx, WELS_LOG_ERROR, WelsLog (pLogCtx, WELS_LOG_ERROR,
"ParamValidationExt(), pSlice setting for SM_RASTER_SLICE now turn to SM_SINGLE_SLICE!\n"); "ParamValidationExt(), pSlice setting for SM_RASTER_SLICE now turn to SM_SINGLE_SLICE!");
pSpatialLayer->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE; pSpatialLayer->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
break; break;
} }
if ((pCodingParam->iRCMode != RC_OFF_MODE) && pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum > 1) { if ((pCodingParam->iRCMode != RC_OFF_MODE) && pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum > 1) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), WARNING: GOM based RC do not support SM_RASTER_SLICE!\n"); WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), WARNING: GOM based RC do not support SM_RASTER_SLICE!");
} }
// considering the coding efficient and performance, iCountMbNum constraint by MIN_NUM_MB_PER_SLICE condition of multi-pSlice mode settting // considering the coding efficient and performance, iCountMbNum constraint by MIN_NUM_MB_PER_SLICE condition of multi-pSlice mode settting
if (iMbNumInFrame <= MIN_NUM_MB_PER_SLICE) { if (iMbNumInFrame <= MIN_NUM_MB_PER_SLICE) {
@@ -377,19 +377,19 @@ int32_t ParamValidationExt (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPa
iMbHeight = (kiPicHeight + 15) >> 4; iMbHeight = (kiPicHeight + 15) >> 4;
iMaxSliceNum = MAX_SLICES_NUM; iMaxSliceNum = MAX_SLICES_NUM;
if (iMbHeight > iMaxSliceNum) { if (iMbHeight > iMaxSliceNum) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) settings more than MAX!\n", iMbHeight); WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) settings more than MAX!", iMbHeight);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum = iMbHeight; pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum = iMbHeight;
if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum <= 0) { if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum <= 0) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) settings!\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceNum (%d) settings!",
pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum); pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceNum);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if (!CheckRowMbMultiSliceSetting (iMbWidth, if (!CheckRowMbMultiSliceSetting (iMbWidth,
&pSpatialLayer->sSliceCfg.sSliceArgument)) { // verify interleave mode settings &pSpatialLayer->sSliceCfg.sSliceArgument)) { // verify interleave mode settings
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMbNum (%d) settings!",
pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0]); pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceMbNum[0]);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
@@ -399,13 +399,13 @@ int32_t ParamValidationExt (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPa
iMbWidth = (kiPicWidth + 15) >> 4; iMbWidth = (kiPicWidth + 15) >> 4;
iMbHeight = (kiPicHeight + 15) >> 4; iMbHeight = (kiPicHeight + 15) >> 4;
if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint <= 0) { if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint <= 0) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid iSliceSize (%d) settings!\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid iSliceSize (%d) settings!",
pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint); pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
if (pCodingParam->uiMaxNalSize <= NAL_HEADER_ADD_0X30BYTES) { if (pCodingParam->uiMaxNalSize <= NAL_HEADER_ADD_0X30BYTES) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiMaxNalSize (%d) settings!\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiMaxNalSize (%d) settings!",
pCodingParam->uiMaxNalSize); pCodingParam->uiMaxNalSize);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
} }
@@ -413,7 +413,7 @@ int32_t ParamValidationExt (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPa
if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint > (pCodingParam->uiMaxNalSize - if (pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint > (pCodingParam->uiMaxNalSize -
NAL_HEADER_ADD_0X30BYTES)) { NAL_HEADER_ADD_0X30BYTES)) {
WelsLog (pLogCtx, WELS_LOG_WARNING, WelsLog (pLogCtx, WELS_LOG_WARNING,
"ParamValidationExt(), slice mode = SM_DYN_SLICE, uiSliceSizeConstraint = %d ,uiMaxNalsize = %d!\n", "ParamValidationExt(), slice mode = SM_DYN_SLICE, uiSliceSizeConstraint = %d ,uiMaxNalsize = %d!",
pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint, pCodingParam->uiMaxNalSize); pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint, pCodingParam->uiMaxNalSize);
pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint = pCodingParam->uiMaxNalSize - NAL_HEADER_ADD_0X30BYTES; pSpatialLayer->sSliceCfg.sSliceArgument.uiSliceSizeConstraint = pCodingParam->uiMaxNalSize - NAL_HEADER_ADD_0X30BYTES;
} }
@@ -421,7 +421,7 @@ int32_t ParamValidationExt (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPa
} }
break; break;
default: { default: {
WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMode (%d) settings!\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "ParamValidationExt(), invalid uiSliceMode (%d) settings!",
pCodingParam->sSpatialLayers[0].sSliceCfg.uiSliceMode); pCodingParam->sSpatialLayers[0].sSliceCfg.uiSliceMode);
return ENC_RETURN_UNSUPPORTED_PARA; return ENC_RETURN_UNSUPPORTED_PARA;
@@ -530,7 +530,7 @@ static inline int32_t AcquireLayersNals (sWelsEncCtx** ppCtx, SWelsSvcCodingPara
assert (iCountNumNals - iOrgNumNals <= MAX_NAL_UNITS_IN_LAYER); assert (iCountNumNals - iOrgNumNals <= MAX_NAL_UNITS_IN_LAYER);
if (kiNumOfSlice > MAX_SLICES_NUM) { if (kiNumOfSlice > MAX_SLICES_NUM) {
WelsLog (& (*ppCtx)->sLogCtx, WELS_LOG_ERROR, WelsLog (& (*ppCtx)->sLogCtx, WELS_LOG_ERROR,
"AcquireLayersNals(), num_of_slice(%d) > MAX_SLICES_NUM(%d) per (iDid= %d, qid= %d) settings!\n", "AcquireLayersNals(), num_of_slice(%d) > MAX_SLICES_NUM(%d) per (iDid= %d, qid= %d) settings!",
kiNumOfSlice, MAX_SLICES_NUM, iDIndex, 0); kiNumOfSlice, MAX_SLICES_NUM, iDIndex, 0);
return 1; return 1;
} }
@@ -538,7 +538,7 @@ static inline int32_t AcquireLayersNals (sWelsEncCtx** ppCtx, SWelsSvcCodingPara
if (iCountNumNals - iOrgNumNals > MAX_NAL_UNITS_IN_LAYER) { if (iCountNumNals - iOrgNumNals > MAX_NAL_UNITS_IN_LAYER) {
WelsLog (& (*ppCtx)->sLogCtx, WELS_LOG_ERROR, WelsLog (& (*ppCtx)->sLogCtx, WELS_LOG_ERROR,
"AcquireLayersNals(), num_of_nals(%d) > MAX_NAL_UNITS_IN_LAYER(%d) per (iDid= %d, qid= %d) settings!\n", "AcquireLayersNals(), num_of_nals(%d) > MAX_NAL_UNITS_IN_LAYER(%d) per (iDid= %d, qid= %d) settings!",
(iCountNumNals - iOrgNumNals), MAX_NAL_UNITS_IN_LAYER, iDIndex, 0); (iCountNumNals - iOrgNumNals), MAX_NAL_UNITS_IN_LAYER, iDIndex, 0);
return 1; return 1;
} }
@@ -1310,7 +1310,7 @@ int32_t RequestMemorySvc (sWelsEncCtx** ppCtx) {
int32_t iTargetSpatialBsSize = 0; int32_t iTargetSpatialBsSize = 0;
if (kiNumDependencyLayers < 1 || kiNumDependencyLayers > MAX_DEPENDENCY_LAYER) { if (kiNumDependencyLayers < 1 || kiNumDependencyLayers > MAX_DEPENDENCY_LAYER) {
WelsLog (& (*ppCtx)->sLogCtx, WELS_LOG_WARNING, "RequestMemorySvc() failed due to invalid iNumDependencyLayers(%d)!\n", WelsLog (& (*ppCtx)->sLogCtx, WELS_LOG_WARNING, "RequestMemorySvc() failed due to invalid iNumDependencyLayers(%d)!",
kiNumDependencyLayers); kiNumDependencyLayers);
FreeMemorySvc (ppCtx); FreeMemorySvc (ppCtx);
return 1; return 1;
@@ -1784,7 +1784,7 @@ void FreeMemorySvc (sWelsEncCtx** ppCtx) {
#endif//MEMORY_MONITOR #endif//MEMORY_MONITOR
if ((*ppCtx)->pMemAlign != NULL) { if ((*ppCtx)->pMemAlign != NULL) {
WelsLog (& (*ppCtx)->sLogCtx, WELS_LOG_INFO, "FreeMemorySvc(), verify memory usage (%d bytes) after free..\n", WelsLog (& (*ppCtx)->sLogCtx, WELS_LOG_INFO, "FreeMemorySvc(), verify memory usage (%d bytes) after free..",
(*ppCtx)->pMemAlign->WelsGetMemoryUsage()); (*ppCtx)->pMemAlign->WelsGetMemoryUsage());
delete (*ppCtx)->pMemAlign; delete (*ppCtx)->pMemAlign;
(*ppCtx)->pMemAlign = NULL; (*ppCtx)->pMemAlign = NULL;
@@ -1847,7 +1847,7 @@ int32_t InitSliceSettings (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPar
} }
if (pDlp->sSliceCfg.sSliceArgument.uiSliceNum == 1) { if (pDlp->sSliceCfg.sSliceArgument.uiSliceNum == 1) {
WelsLog (pLogCtx, WELS_LOG_DEBUG, WelsLog (pLogCtx, WELS_LOG_DEBUG,
"InitSliceSettings(), uiSliceNum(%d) you set for SM_AUTO_SLICE, now turn to SM_SINGLE_SLICE type!\n", "InitSliceSettings(), uiSliceNum(%d) you set for SM_AUTO_SLICE, now turn to SM_SINGLE_SLICE type!",
pDlp->sSliceCfg.sSliceArgument.uiSliceNum); pDlp->sSliceCfg.sSliceArgument.uiSliceNum);
pDlp->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE; pDlp->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
break; break;
@@ -1862,7 +1862,7 @@ int32_t InitSliceSettings (SLogContext* pLogCtx, SWelsSvcCodingParam* pCodingPar
&pDlp->sSliceCfg.sSliceArgument)) { // verify interleave mode settings &pDlp->sSliceCfg.sSliceArgument)) { // verify interleave mode settings
//check uiSliceMbNum with current uiSliceNum //check uiSliceMbNum with current uiSliceNum
WelsLog (pLogCtx, WELS_LOG_ERROR, WelsLog (pLogCtx, WELS_LOG_ERROR,
"InitSliceSettings(), invalid uiSliceMbNum (%d) settings!,now turn to SM_SINGLE_SLICE type\n", "InitSliceSettings(), invalid uiSliceMbNum (%d) settings!,now turn to SM_SINGLE_SLICE type",
pDlp->sSliceCfg.sSliceArgument.uiSliceMbNum[0]); pDlp->sSliceCfg.sSliceArgument.uiSliceMbNum[0]);
pDlp->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE; pDlp->sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
pDlp->sSliceCfg.sSliceArgument.uiSliceNum = 1; pDlp->sSliceCfg.sSliceArgument.uiSliceNum = 1;
@@ -1918,7 +1918,7 @@ void OutputCpuFeaturesLog (SLogContext* pLogCtx, uint32_t uiCpuFeatureFlags, uin
"MOVBE: %c, " \ "MOVBE: %c, " \
"AES: %c, " \ "AES: %c, " \
"NUMBER OF LOGIC PROCESSORS ON CHIP: %d, " \ "NUMBER OF LOGIC PROCESSORS ON CHIP: %d, " \
"CPU CACHE LINE SIZE (BYTES): %d\n", "CPU CACHE LINE SIZE (BYTES): %d",
uiCpuFeatureFlags, uiCpuFeatureFlags,
(uiCpuFeatureFlags & WELS_CPU_HTT) ? 'Y' : 'N', (uiCpuFeatureFlags & WELS_CPU_HTT) ? 'Y' : 'N',
(uiCpuFeatureFlags & WELS_CPU_MMX) ? 'Y' : 'N', (uiCpuFeatureFlags & WELS_CPU_MMX) ? 'Y' : 'N',
@@ -1958,14 +1958,14 @@ int32_t WelsInitEncoderExt (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingPar
int16_t iSliceNum = 1; // number of slices used int16_t iSliceNum = 1; // number of slices used
if (NULL == ppCtx || NULL == pCodingParam) { if (NULL == ppCtx || NULL == pCodingParam) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), NULL == ppCtx(0x%p) or NULL == pCodingParam(0x%p).\n", WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), NULL == ppCtx(0x%p) or NULL == pCodingParam(0x%p).",
(void*)ppCtx, (void*)pCodingParam); (void*)ppCtx, (void*)pCodingParam);
return 1; return 1;
} }
iRet = ParamValidationExt (pLogCtx, pCodingParam); iRet = ParamValidationExt (pLogCtx, pCodingParam);
if (iRet != 0) { if (iRet != 0) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), ParamValidationExt failed return %d.\n", iRet); WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), ParamValidationExt failed return %d.", iRet);
return iRet; return iRet;
} }
@@ -2004,7 +2004,7 @@ int32_t WelsInitEncoderExt (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingPar
uiCpuCores = WELS_CLIP3 (uiCpuCores, 1, MAX_THREADS_NUM); uiCpuCores = WELS_CLIP3 (uiCpuCores, 1, MAX_THREADS_NUM);
if (InitSliceSettings (pLogCtx, pCodingParam, uiCpuCores, &iSliceNum)) { if (InitSliceSettings (pLogCtx, pCodingParam, uiCpuCores, &iSliceNum)) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), InitSliceSettings failed.\n"); WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), InitSliceSettings failed.");
return 1; return 1;
} }
@@ -2039,7 +2039,7 @@ int32_t WelsInitEncoderExt (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingPar
pCtx->iMaxSliceCount = iSliceNum; pCtx->iMaxSliceCount = iSliceNum;
iRet = RequestMemorySvc (&pCtx); iRet = RequestMemorySvc (&pCtx);
if (iRet != 0) { if (iRet != 0) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), RequestMemorySvc failed return %d.\n", iRet); WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), RequestMemorySvc failed return %d.", iRet);
FreeMemorySvc (&pCtx); FreeMemorySvc (&pCtx);
return iRet; return iRet;
} }
@@ -2052,18 +2052,18 @@ int32_t WelsInitEncoderExt (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingPar
pCtx->pVpp = new CWelsPreProcess (pCtx); pCtx->pVpp = new CWelsPreProcess (pCtx);
if (pCtx->pVpp == NULL) { if (pCtx->pVpp == NULL) {
iRet = 1; iRet = 1;
WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), pOut of memory in case new CWelsPreProcess().\n"); WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), pOut of memory in case new CWelsPreProcess().");
FreeMemorySvc (&pCtx); FreeMemorySvc (&pCtx);
return iRet; return iRet;
} }
if ((iRet = pCtx->pVpp->AllocSpatialPictures (pCtx, pCtx->pSvcParam)) != 0) { if ((iRet = pCtx->pVpp->AllocSpatialPictures (pCtx, pCtx->pSvcParam)) != 0) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), pVPP alloc spatial pictures failed\n"); WelsLog (pLogCtx, WELS_LOG_ERROR, "WelsInitEncoderExt(), pVPP alloc spatial pictures failed");
FreeMemorySvc (&pCtx); FreeMemorySvc (&pCtx);
return iRet; return iRet;
} }
#if defined(MEMORY_MONITOR) #if defined(MEMORY_MONITOR)
WelsLog (pLogCtx, WELS_LOG_INFO, "WelsInitEncoderExt() exit, overall memory usage: %llu bytes\n", WelsLog (pLogCtx, WELS_LOG_INFO, "WelsInitEncoderExt() exit, overall memory usage: %llu bytes",
static_cast<unsigned long long> (sizeof (sWelsEncCtx) /* requested size from malloc() or new operator */ static_cast<unsigned long long> (sizeof (sWelsEncCtx) /* requested size from malloc() or new operator */
+ pCtx->pMemAlign->WelsGetMemoryUsage()) /* requested size from CMemoryAlign::WelsMalloc() */ + pCtx->pMemAlign->WelsGetMemoryUsage()) /* requested size from CMemoryAlign::WelsMalloc() */
); );
@@ -2071,7 +2071,7 @@ int32_t WelsInitEncoderExt (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingPar
*ppCtx = pCtx; *ppCtx = pCtx;
WelsLog (pLogCtx, WELS_LOG_DEBUG, "WelsInitEncoderExt(), pCtx= 0x%p.\n", (void*)pCtx); WelsLog (pLogCtx, WELS_LOG_DEBUG, "WelsInitEncoderExt(), pCtx= 0x%p.", (void*)pCtx);
return 0; return 0;
} }
@@ -2165,7 +2165,7 @@ void WelsUninitEncoderExt (sWelsEncCtx** ppCtx) {
return; return;
WelsLog (& (*ppCtx)->sLogCtx, WELS_LOG_INFO, WelsLog (& (*ppCtx)->sLogCtx, WELS_LOG_INFO,
"WelsUninitEncoderExt(), pCtx= %p, iThreadCount= %d, iMultipleThreadIdc= %d.\n", "WelsUninitEncoderExt(), pCtx= %p, iThreadCount= %d, iMultipleThreadIdc= %d.",
(void*) (*ppCtx), (*ppCtx)->pSvcParam->iCountThreadsNum, (*ppCtx)->pSvcParam->iMultipleThreadIdc); (void*) (*ppCtx), (*ppCtx)->pSvcParam->iCountThreadsNum, (*ppCtx)->pSvcParam->iMultipleThreadIdc);
#if defined(STAT_OUTPUT) #if defined(STAT_OUTPUT)
@@ -2183,7 +2183,7 @@ void WelsUninitEncoderExt (sWelsEncCtx** ppCtx) {
WelsEventSignal (& (*ppCtx)->pSliceThreading->pExitEncodeEvent[iThreadIdx]); WelsEventSignal (& (*ppCtx)->pSliceThreading->pExitEncodeEvent[iThreadIdx]);
WelsEventSignal (& (*ppCtx)->pSliceThreading->pThreadMasterEvent[iThreadIdx]); WelsEventSignal (& (*ppCtx)->pSliceThreading->pThreadMasterEvent[iThreadIdx]);
res = WelsThreadJoin ((*ppCtx)->pSliceThreading->pThreadHandles[iThreadIdx]); // waiting thread exit res = WelsThreadJoin ((*ppCtx)->pSliceThreading->pThreadHandles[iThreadIdx]); // waiting thread exit
WelsLog (& (*ppCtx)->sLogCtx, WELS_LOG_INFO, "WelsUninitEncoderExt(), pthread_join(pThreadHandles%d) return %d..\n", WelsLog (& (*ppCtx)->sLogCtx, WELS_LOG_INFO, "WelsUninitEncoderExt(), pthread_join(pThreadHandles%d) return %d..",
iThreadIdx, iThreadIdx,
res); res);
(*ppCtx)->pSliceThreading->pThreadHandles[iThreadIdx] = 0; (*ppCtx)->pSliceThreading->pThreadHandles[iThreadIdx] = 0;
@@ -2351,7 +2351,7 @@ void WelsInitCurrentDlayerMltslc (sWelsEncCtx* pCtx, int32_t iPartitionNum) {
WelsLog (& (pCtx->sLogCtx), WelsLog (& (pCtx->sLogCtx),
WELS_LOG_WARNING, WELS_LOG_WARNING,
"Set-SliceConstraint(%d) too small for current resolution (MB# %d) under QP/BR!\n", "Set-SliceConstraint(%d) too small for current resolution (MB# %d) under QP/BR!",
pSliceCtx->uiSliceSizeConstraint, pSliceCtx->uiSliceSizeConstraint,
pSliceCtx->iMbNumInFrame pSliceCtx->iMbNumInFrame
); );
@@ -2561,7 +2561,7 @@ void PreprocessSliceCoding (sWelsEncCtx* pCtx) {
pFuncList->pfMotionSearch[SCROLLED_STATIC] = WelsMotionEstimateSearchScrolled; pFuncList->pfMotionSearch[SCROLLED_STATIC] = WelsMotionEstimateSearchScrolled;
//ME16x16 //ME16x16
if (!SetMeMethod (ME_DIA_CROSS, pFuncList->pfSearchMethod[BLOCK_16x16])) { if (!SetMeMethod (ME_DIA_CROSS, pFuncList->pfSearchMethod[BLOCK_16x16])) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "SetMeMethod(BLOCK_16x16) ME_DIA_CROSS unsuccessful, switched to default search\n"); WelsLog (pLogCtx, WELS_LOG_WARNING, "SetMeMethod(BLOCK_16x16) ME_DIA_CROSS unsuccessful, switched to default search");
} }
//ME8x8 //ME8x8
SFeatureSearchPreparation* pFeatureSearchPreparation = pCurLayer->pFeatureSearchPreparation; SFeatureSearchPreparation* pFeatureSearchPreparation = pCurLayer->pFeatureSearchPreparation;
@@ -2589,7 +2589,7 @@ void PreprocessSliceCoding (sWelsEncCtx* pCtx) {
&& (!pScreenBlockFeatureStorage->iIs16x16)) { && (!pScreenBlockFeatureStorage->iIs16x16)) {
if (!SetMeMethod (ME_DIA_CROSS_FME, pFuncList->pfSearchMethod[BLOCK_8x8])) { if (!SetMeMethod (ME_DIA_CROSS_FME, pFuncList->pfSearchMethod[BLOCK_8x8])) {
WelsLog (pLogCtx, WELS_LOG_WARNING, WelsLog (pLogCtx, WELS_LOG_WARNING,
"SetMeMethod(BLOCK_8x8) ME_DIA_CROSS_FME unsuccessful, switched to default search\n"); "SetMeMethod(BLOCK_8x8) ME_DIA_CROSS_FME unsuccessful, switched to default search");
} }
} }
@@ -2861,7 +2861,7 @@ int32_t WritePadding (sWelsEncCtx* pCtx, int32_t iLen, int32_t& iSize) {
if ((pBs->pBufEnd - pBs->pBufPtr) < iLen || iNal >= pCtx->pOut->iCountNals) { if ((pBs->pBufEnd - pBs->pBufPtr) < iLen || iNal >= pCtx->pOut->iCountNals) {
#if GOM_TRACE_FLAG #if GOM_TRACE_FLAG
WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR,
"[RC] paddingcal pBuffer overflow, bufferlen=%lld, paddinglen=%d, iNalIdx= %d, iCountNals= %d\n", "[RC] paddingcal pBuffer overflow, bufferlen=%lld, paddinglen=%d, iNalIdx= %d, iCountNals= %d",
static_cast<long long int> (pBs->pBufEnd - pBs->pBufPtr), iLen, iNal, pCtx->pOut->iCountNals); static_cast<long long int> (pBs->pBufEnd - pBs->pBufPtr), iLen, iNal, pCtx->pOut->iCountNals);
#endif #endif
return ENC_RETURN_MEMOVERFLOWFOUND; return ENC_RETURN_MEMOVERFLOWFOUND;
@@ -3153,7 +3153,7 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour
// Force coding IDR as followed // Force coding IDR as followed
ForceCodingIDR (pCtx); ForceCodingIDR (pCtx);
WelsLog (pLogCtx, WELS_LOG_WARNING, WelsLog (pLogCtx, WELS_LOG_WARNING,
"WelsEncoderEncodeExt(), WelsBuildRefList failed for P frames, pCtx->iNumRef0= %d. ForceCodingIDR!\n", "WelsEncoderEncodeExt(), WelsBuildRefList failed for P frames, pCtx->iNumRef0= %d. ForceCodingIDR!",
pCtx->iNumRef0); pCtx->iNumRef0);
pFbi->eFrameType = videoFrameTypeIDR; pFbi->eFrameType = videoFrameTypeIDR;
pCtx->iEncoderError = ENC_RETURN_CORRECTED; pCtx->iEncoderError = ENC_RETURN_CORRECTED;
@@ -3232,7 +3232,7 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour
} }
if (iSliceCount <= 1) { if (iSliceCount <= 1) {
WelsLog (pLogCtx, WELS_LOG_ERROR, WelsLog (pLogCtx, WELS_LOG_ERROR,
"WelsEncoderEncodeExt(), iSliceCount(%d) from GetCurrentSliceNum() is untrusted due stack/heap crupted!\n", "WelsEncoderEncodeExt(), iSliceCount(%d) from GetCurrentSliceNum() is untrusted due stack/heap crupted!",
iSliceCount); iSliceCount);
return ENC_RETURN_UNEXPECTED; return ENC_RETURN_UNEXPECTED;
} }
@@ -3250,7 +3250,7 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour
pLayerBsInfo, iSliceCount, pCtx->pCurDqLayer->pSliceEncCtx, false); pLayerBsInfo, iSliceCount, pCtx->pCurDqLayer->pSliceEncCtx, false);
if (iRet) { if (iRet) {
WelsLog (pLogCtx, WELS_LOG_ERROR, WelsLog (pLogCtx, WELS_LOG_ERROR,
"[MT] WelsEncoderEncodeExt(), FiredSliceThreads return(%d) failed and exit encoding frame, iCountThreadsNum= %d, iSliceCount= %d, uiSliceMode= %d, iMultipleThreadIdc= %d!!\n", "[MT] WelsEncoderEncodeExt(), FiredSliceThreads return(%d) failed and exit encoding frame, iCountThreadsNum= %d, iSliceCount= %d, uiSliceMode= %d, iMultipleThreadIdc= %d!!",
iRet, pSvcParam->iCountThreadsNum, iSliceCount, pParam->sSliceCfg.uiSliceMode, pSvcParam->iMultipleThreadIdc); iRet, pSvcParam->iCountThreadsNum, iSliceCount, pParam->sSliceCfg.uiSliceMode, pSvcParam->iMultipleThreadIdc);
return ENC_RETURN_UNEXPECTED; return ENC_RETURN_UNEXPECTED;
} }
@@ -3290,7 +3290,7 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour
pLayerBsInfo, iNumThreadsRunning, pCtx->pCurDqLayer->pSliceEncCtx, false); pLayerBsInfo, iNumThreadsRunning, pCtx->pCurDqLayer->pSliceEncCtx, false);
if (iRet) { if (iRet) {
WelsLog (pLogCtx, WELS_LOG_ERROR, WelsLog (pLogCtx, WELS_LOG_ERROR,
"[MT] WelsEncoderEncodeExt(), FiredSliceThreads return(%d) failed and exit encoding frame, iCountThreadsNum= %d, iSliceCount= %d, uiSliceMode= %d, iMultipleThreadIdc= %d!!\n", "[MT] WelsEncoderEncodeExt(), FiredSliceThreads return(%d) failed and exit encoding frame, iCountThreadsNum= %d, iSliceCount= %d, uiSliceMode= %d, iMultipleThreadIdc= %d!!",
iRet, pSvcParam->iCountThreadsNum, iSliceCount, pParam->sSliceCfg.uiSliceMode, pSvcParam->iMultipleThreadIdc); iRet, pSvcParam->iCountThreadsNum, iSliceCount, pParam->sSliceCfg.uiSliceMode, pSvcParam->iMultipleThreadIdc);
return ENC_RETURN_UNEXPECTED; return ENC_RETURN_UNEXPECTED;
} }
@@ -3337,7 +3337,7 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour
pLayerBsInfo, kiPartitionCnt, pCtx->pCurDqLayer->pSliceEncCtx, true); pLayerBsInfo, kiPartitionCnt, pCtx->pCurDqLayer->pSliceEncCtx, true);
if (iRet) { if (iRet) {
WelsLog (pLogCtx, WELS_LOG_ERROR, WelsLog (pLogCtx, WELS_LOG_ERROR,
"[MT] WelsEncoderEncodeExt(), FiredSliceThreads return(%d) failed and exit encoding frame, iCountThreadsNum= %d, iSliceCount= %d, uiSliceMode= %d, iMultipleThreadIdc= %d!!\n", "[MT] WelsEncoderEncodeExt(), FiredSliceThreads return(%d) failed and exit encoding frame, iCountThreadsNum= %d, iSliceCount= %d, uiSliceMode= %d, iMultipleThreadIdc= %d!!",
iRet, pSvcParam->iCountThreadsNum, iSliceCount, pParam->sSliceCfg.uiSliceMode, pSvcParam->iMultipleThreadIdc); iRet, pSvcParam->iCountThreadsNum, iSliceCount, pParam->sSliceCfg.uiSliceMode, pSvcParam->iMultipleThreadIdc);
return ENC_RETURN_UNEXPECTED; return ENC_RETURN_UNEXPECTED;
} }
@@ -3422,7 +3422,7 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour
if (!pCtx->pFuncList->pUpdateRefList (pCtx)) { if (!pCtx->pFuncList->pUpdateRefList (pCtx)) {
// Force coding IDR as followed // Force coding IDR as followed
ForceCodingIDR (pCtx); ForceCodingIDR (pCtx);
WelsLog (pLogCtx, WELS_LOG_WARNING, "WelsEncoderEncodeExt(), WelsUpdateRefList failed. ForceCodingIDR!\n"); WelsLog (pLogCtx, WELS_LOG_WARNING, "WelsEncoderEncodeExt(), WelsUpdateRefList failed. ForceCodingIDR!");
//the above is to set the next frame to be IDR //the above is to set the next frame to be IDR
pFbi->eFrameType = eFrameType; pFbi->eFrameType = eFrameType;
return ENC_RETURN_CORRECTED; return ENC_RETURN_CORRECTED;
@@ -3528,7 +3528,7 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour
WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS) WELS_VERIFY_RETURN_IFNEQ (pCtx->iEncoderError, ENC_RETURN_SUCCESS)
#if GOM_TRACE_FLAG #if GOM_TRACE_FLAG
WelsLog (pLogCtx, WELS_LOG_INFO, "[RC] encoding_qp%d Padding: %d\n", pCtx->uiDependencyId, WelsLog (pLogCtx, WELS_LOG_INFO, "[RC] encoding_qp%d Padding: %d", pCtx->uiDependencyId,
pCtx->pWelsSvcRc[pCtx->uiDependencyId].iPaddingSize); pCtx->pWelsSvcRc[pCtx->uiDependencyId].iPaddingSize);
#endif #endif
if (iPaddingNalSize <= 0) if (iPaddingNalSize <= 0)
@@ -3573,7 +3573,7 @@ int32_t WelsEncoderEncodeExt (sWelsEncCtx* pCtx, SFrameBSInfo* pFbi, const SSour
if (pCtx->pVpp->UpdateSpatialPictures (pCtx, pSvcParam, iCurTid, iDidIdx) != 0) { if (pCtx->pVpp->UpdateSpatialPictures (pCtx, pSvcParam, iCurTid, iDidIdx) != 0) {
ForceCodingIDR (pCtx); ForceCodingIDR (pCtx);
WelsLog (pLogCtx, WELS_LOG_WARNING, "WelsEncoderEncodeExt(), Logic Error Found in temporal level. ForceCodingIDR!\n"); WelsLog (pLogCtx, WELS_LOG_WARNING, "WelsEncoderEncodeExt(), Logic Error Found in temporal level. ForceCodingIDR!");
//the above is to set the next frame IDR //the above is to set the next frame IDR
pFbi->eFrameType = eFrameType; pFbi->eFrameType = eFrameType;
return ENC_RETURN_CORRECTED; return ENC_RETURN_CORRECTED;

6
codec/encoder/core/src/ratectl.cpp
View File

@@ -348,11 +348,11 @@ void RcTraceVGopBitrate (sWelsEncCtx* pEncCtx) {
#ifdef _TEST_TEMP_Rc_ #ifdef _TEST_TEMP_Rc_
fprintf (fp_vgop, "%d\n", WELS_ROUND ((double)iTotalBits / iFrameInVGop)); fprintf (fp_vgop, "%d\n", WELS_ROUND ((double)iTotalBits / iFrameInVGop));
#endif #endif
WelsLog (& (pEncCtx->sLogCtx), WELS_LOG_INFO, "[Rc] VGOPbitrate%d: %d \n", kiDid, iVGopBitrate); WelsLog (& (pEncCtx->sLogCtx), WELS_LOG_INFO, "[Rc] VGOPbitrate%d: %d ", kiDid, iVGopBitrate);
if (iTotalBits > 0) { if (iTotalBits > 0) {
iTid = 0; iTid = 0;
while (iTid <= kiHighestTid) { while (iTid <= kiHighestTid) {
WelsLog (& (pEncCtx->sLogCtx), WELS_LOG_INFO, "T%d=%8.3f \n", iTid, (double) (pTOverRc[iTid].iGopBitsDq / iTotalBits)); WelsLog (& (pEncCtx->sLogCtx), WELS_LOG_INFO, "T%d=%8.3f ", iTid, (double) (pTOverRc[iTid].iGopBitsDq / iTotalBits));
++ iTid; ++ iTid;
} }
} }
@@ -760,7 +760,7 @@ void RcTraceFrameBits (sWelsEncCtx* pEncCtx) {
SWelsSvcRc* pWelsSvcRc = &pEncCtx->pWelsSvcRc[pEncCtx->uiDependencyId]; SWelsSvcRc* pWelsSvcRc = &pEncCtx->pWelsSvcRc[pEncCtx->uiDependencyId];
WelsLog (& (pEncCtx->sLogCtx), WELS_LOG_INFO, WelsLog (& (pEncCtx->sLogCtx), WELS_LOG_INFO,
"[Rc] encoding_qp%d, qp = %3d, index = %8d, iTid = %1d, used = %8d, target = %8d, remaingbits = %8d\n", "[Rc] encoding_qp%d, qp = %3d, index = %8d, iTid = %1d, used = %8d, target = %8d, remaingbits = %8d",
pEncCtx->uiDependencyId, pWelsSvcRc->iAverageFrameQp, pEncCtx->iFrameIndex, pEncCtx->uiTemporalId, pEncCtx->uiDependencyId, pWelsSvcRc->iAverageFrameQp, pEncCtx->iFrameIndex, pEncCtx->uiTemporalId,
pWelsSvcRc->iFrameDqBits, pWelsSvcRc->iFrameDqBits,
pWelsSvcRc->iTargetBits, pWelsSvcRc->iRemainingBits); pWelsSvcRc->iTargetBits, pWelsSvcRc->iRemainingBits);

16
codec/encoder/core/src/ref_list_mgr_svc.cpp
View File

@@ -179,7 +179,7 @@ static inline void DeleteInvalidLTR (sWelsEncCtx* pCtx) {
if (CompareFrameNum (pLongRefList[i]->iFrameNum , pLtr->iLastCorFrameNumDec, iMaxFrameNumPlus1) == FRAME_NUM_BIGGER if (CompareFrameNum (pLongRefList[i]->iFrameNum , pLtr->iLastCorFrameNumDec, iMaxFrameNumPlus1) == FRAME_NUM_BIGGER
&& (CompareFrameNum (pLongRefList[i]->iFrameNum , pLtr->iCurFrameNumInDec, && (CompareFrameNum (pLongRefList[i]->iFrameNum , pLtr->iCurFrameNumInDec,
iMaxFrameNumPlus1) & (FRAME_NUM_EQUAL | FRAME_NUM_SMALLER))) { iMaxFrameNumPlus1) & (FRAME_NUM_EQUAL | FRAME_NUM_SMALLER))) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "LTR ,invalid LTR delete ,long_term_idx = %d , iFrameNum =%d \n", WelsLog (pLogCtx, WELS_LOG_WARNING, "LTR ,invalid LTR delete ,long_term_idx = %d , iFrameNum =%d ",
pLongRefList[i]->iLongTermPicNum, pLongRefList[i]->iFrameNum); pLongRefList[i]->iLongTermPicNum, pLongRefList[i]->iFrameNum);
SetUnref (pLongRefList[i]); SetUnref (pLongRefList[i]);
DeleteLTRFromLongList (pCtx, i); DeleteLTRFromLongList (pCtx, i);
@@ -192,7 +192,7 @@ static inline void DeleteInvalidLTR (sWelsEncCtx* pCtx) {
&& (CompareFrameNum (pLongRefList[i]->iMarkFrameNum, pLtr->iCurFrameNumInDec , && (CompareFrameNum (pLongRefList[i]->iMarkFrameNum, pLtr->iCurFrameNumInDec ,
iMaxFrameNumPlus1) & (FRAME_NUM_EQUAL | FRAME_NUM_SMALLER)) iMaxFrameNumPlus1) & (FRAME_NUM_EQUAL | FRAME_NUM_SMALLER))
&& pLtr->iLTRMarkMode == LTR_DELAY_MARK) { && pLtr->iLTRMarkMode == LTR_DELAY_MARK) {
WelsLog (pLogCtx, WELS_LOG_WARNING, "LTR ,iMarkFrameNum invalid LTR delete ,long_term_idx = %d , iFrameNum =%d \n", WelsLog (pLogCtx, WELS_LOG_WARNING, "LTR ,iMarkFrameNum invalid LTR delete ,long_term_idx = %d , iFrameNum =%d ",
pLongRefList[i]->iLongTermPicNum, pLongRefList[i]->iFrameNum); pLongRefList[i]->iLongTermPicNum, pLongRefList[i]->iFrameNum);
SetUnref (pLongRefList[i]); SetUnref (pLongRefList[i]);
DeleteLTRFromLongList (pCtx, i); DeleteLTRFromLongList (pCtx, i);
@@ -602,7 +602,7 @@ bool WelsBuildRefList (void* pEncCtx, const int32_t iPOC, int32_t iBestLtrRefIdx
if (pRef != NULL && pRef->bUsedAsRef && pRef->iFramePoc >= 0 && pRef->uiTemporalId <= kuiTid) { if (pRef != NULL && pRef->bUsedAsRef && pRef->iFramePoc >= 0 && pRef->uiTemporalId <= kuiTid) {
pCtx->pRefList0[pCtx->iNumRef0++] = pRef; pCtx->pRefList0[pCtx->iNumRef0++] = pRef;
WelsLog (& (pCtx->sLogCtx), WELS_LOG_DETAIL, WelsLog (& (pCtx->sLogCtx), WELS_LOG_DETAIL,
"WelsBuildRefList pCtx->uiTemporalId = %d,pRef->iFrameNum = %d,pRef->uiTemporalId = %d\n", "WelsBuildRefList pCtx->uiTemporalId = %d,pRef->iFrameNum = %d,pRef->uiTemporalId = %d",
pCtx->uiTemporalId, pRef->iFrameNum, pRef->uiTemporalId); pCtx->uiTemporalId, pRef->iFrameNum, pRef->uiTemporalId);
break; break;
} }
@@ -645,9 +645,9 @@ void WelsUpdateRefSyntax (sWelsEncCtx* pCtx, const int32_t iPOC, const int32_t u
if (pCtx->iNumRef0 > 0) { if (pCtx->iNumRef0 > 0) {
if ((!pCtx->pRefList0[0]->bIsLongRef) || (!pCtx->pSvcParam->bEnableLongTermReference)) { if ((!pCtx->pRefList0[0]->bIsLongRef) || (!pCtx->pSvcParam->bEnableLongTermReference)) {
if (iAbsDiffPicNumMinus1 < 0) { if (iAbsDiffPicNumMinus1 < 0) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, "WelsUpdateRefSyntax():::uiAbsDiffPicNumMinus1:%d\n", iAbsDiffPicNumMinus1); WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, "WelsUpdateRefSyntax():::uiAbsDiffPicNumMinus1:%d", iAbsDiffPicNumMinus1);
iAbsDiffPicNumMinus1 += (1 << (pCtx->pSps->uiLog2MaxFrameNum)); iAbsDiffPicNumMinus1 += (1 << (pCtx->pSps->uiLog2MaxFrameNum));
WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, "WelsUpdateRefSyntax():::uiAbsDiffPicNumMinus1< 0, update as:%d\n", WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, "WelsUpdateRefSyntax():::uiAbsDiffPicNumMinus1< 0, update as:%d",
iAbsDiffPicNumMinus1); iAbsDiffPicNumMinus1);
} }
@@ -778,11 +778,11 @@ bool WelsBuildRefListScreen (void* pEncCtx, const int32_t iPOC, int32_t iBestLtr
pCtx->pCurDqLayer->pRefOri[pCtx->iNumRef0] = pRefOri; pCtx->pCurDqLayer->pRefOri[pCtx->iNumRef0] = pRefOri;
pCtx->pRefList0[pCtx->iNumRef0++] = pRefPic; pCtx->pRefList0[pCtx->iNumRef0++] = pRefPic;
WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO,
"WelsBuildRefListScreen(), ref !current iFrameNum = %d, ref iFrameNum = %d,LTR number = %d,iNumRef = %d ref is Scene LTR = %d\n", "WelsBuildRefListScreen(), ref !current iFrameNum = %d, ref iFrameNum = %d,LTR number = %d,iNumRef = %d ref is Scene LTR = %d",
pCtx->iFrameNum, pCtx->pRefList0[pCtx->iNumRef0 - 1]->iFrameNum, pRefList->uiLongRefCount, iNumRef, pCtx->iFrameNum, pCtx->pRefList0[pCtx->iNumRef0 - 1]->iFrameNum, pRefList->uiLongRefCount, iNumRef,
pRefPic->bIsSceneLTR); pRefPic->bIsSceneLTR);
WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO,
"WelsBuildRefListScreen pCtx->uiTemporalId = %d,pRef->iFrameNum = %d,pRef->uiTemporalId = %d\n", "WelsBuildRefListScreen pCtx->uiTemporalId = %d,pRef->iFrameNum = %d,pRef->uiTemporalId = %d",
pCtx->uiTemporalId, pRefPic->iFrameNum, pRefPic->uiTemporalId); pCtx->uiTemporalId, pRefPic->iFrameNum, pRefPic->uiTemporalId);
} }
} }
@@ -795,7 +795,7 @@ bool WelsBuildRefListScreen (void* pEncCtx, const int32_t iPOC, int32_t iBestLtr
pCtx->pCurDqLayer->pRefOri[pCtx->iNumRef0] = pRefOri; pCtx->pCurDqLayer->pRefOri[pCtx->iNumRef0] = pRefOri;
pCtx->pRefList0[pCtx->iNumRef0++] = pRefList->pLongRefList[i]; pCtx->pRefList0[pCtx->iNumRef0++] = pRefList->pLongRefList[i];
WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO, WelsLog (& (pCtx->sLogCtx), WELS_LOG_INFO,
"WelsBuildRefListScreen(), ref !current iFrameNum = %d, ref iFrameNum = %d,LTR number = %d\n", "WelsBuildRefListScreen(), ref !current iFrameNum = %d, ref iFrameNum = %d,LTR number = %d",
pCtx->iFrameNum, pCtx->pRefList0[pCtx->iNumRef0 - 1]->iFrameNum, pRefList->uiLongRefCount); pCtx->iFrameNum, pCtx->pRefList0[pCtx->iNumRef0 - 1]->iFrameNum, pRefList->uiLongRefCount);
break; break;
} }

42
codec/encoder/core/src/slice_multi_threading.cpp
View File

@@ -132,7 +132,7 @@ void CalcSliceComplexRatio (void* pRatio, SSliceCtx* pSliceCtx, uint32_t* pSlice
while (iSliceIdx < kiSliceCount) { while (iSliceIdx < kiSliceCount) {
iAvI[iSliceIdx] = WELS_DIV_ROUND (INT_MULTIPLY * pCountMbInSlice[iSliceIdx], pSliceTime[iSliceIdx]); iAvI[iSliceIdx] = WELS_DIV_ROUND (INT_MULTIPLY * pCountMbInSlice[iSliceIdx], pSliceTime[iSliceIdx]);
MT_TRACE_LOG (NULL, WELS_LOG_DEBUG, "[MT] CalcSliceComplexRatio(), pSliceConsumeTime[%d]= %d us, slice_run= %d\n", MT_TRACE_LOG (NULL, WELS_LOG_DEBUG, "[MT] CalcSliceComplexRatio(), pSliceConsumeTime[%d]= %d us, slice_run= %d",
iSliceIdx, iSliceIdx,
pSliceTime[iSliceIdx], pCountMbInSlice[iSliceIdx]); pSliceTime[iSliceIdx], pCountMbInSlice[iSliceIdx]);
iSumAv += iAvI[iSliceIdx]; iSumAv += iAvI[iSliceIdx];
@@ -158,7 +158,7 @@ int32_t NeedDynamicAdjust (void* pConsumeTime, const int32_t iSliceNum) {
} }
if (uiTotalConsume == 0) { if (uiTotalConsume == 0) {
MT_TRACE_LOG (NULL, WELS_LOG_DEBUG, MT_TRACE_LOG (NULL, WELS_LOG_DEBUG,
"[MT] NeedDynamicAdjust(), herein do no adjust due first picture, iCountSliceNum= %d\n", "[MT] NeedDynamicAdjust(), herein do no adjust due first picture, iCountSliceNum= %d",
iSliceNum); iSliceNum);
return false; return false;
} }
@@ -185,7 +185,7 @@ int32_t NeedDynamicAdjust (void* pConsumeTime, const int32_t iSliceNum) {
if (fRmse > fThr) if (fRmse > fThr)
iNeedAdj = true; iNeedAdj = true;
MT_TRACE_LOG (NULL, WELS_LOG_DEBUG, MT_TRACE_LOG (NULL, WELS_LOG_DEBUG,
"[MT] NeedDynamicAdjust(), herein adjustment decision is made (iNeedAdj= %d) by: fRmse of pSlice complexity ratios %.6f, the corresponding threshold %.6f, iCountSliceNum %d\n", "[MT] NeedDynamicAdjust(), herein adjustment decision is made (iNeedAdj= %d) by: fRmse of pSlice complexity ratios %.6f, the corresponding threshold %.6f, iCountSliceNum %d",
iNeedAdj, fRmse, fThr, iSliceNum); iNeedAdj, fRmse, fThr, iSliceNum);
return iNeedAdj; return iNeedAdj;
@@ -212,7 +212,7 @@ void DynamicAdjustSlicing (sWelsEncCtx* pCtx,
if (iNumMbInEachGom <= 0) { if (iNumMbInEachGom <= 0) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR,
"[MT] DynamicAdjustSlicing(), invalid iNumMbInEachGom= %d from RC, iDid= %d, iCountNumMb= %d\n", iNumMbInEachGom, "[MT] DynamicAdjustSlicing(), invalid iNumMbInEachGom= %d from RC, iDid= %d, iCountNumMb= %d", iNumMbInEachGom,
iCurDid, kiCountNumMb); iCurDid, kiCountNumMb);
return; return;
} }
@@ -232,7 +232,7 @@ void DynamicAdjustSlicing (sWelsEncCtx* pCtx,
WelsEmms(); WelsEmms();
MT_TRACE_LOG (pCtx, WELS_LOG_DEBUG, "[MT] DynamicAdjustSlicing(), iDid= %d, iCountNumMb= %d\n", iCurDid, kiCountNumMb); MT_TRACE_LOG (pCtx, WELS_LOG_DEBUG, "[MT] DynamicAdjustSlicing(), iDid= %d, iCountNumMb= %d", iCurDid, kiCountNumMb);
iSliceIdx = 0; iSliceIdx = 0;
while (iSliceIdx + 1 < kiCountSliceNum) { while (iSliceIdx + 1 < kiCountSliceNum) {
@@ -258,7 +258,7 @@ void DynamicAdjustSlicing (sWelsEncCtx* pCtx,
} }
iRunLen[iSliceIdx] = iNumMbAssigning; iRunLen[iSliceIdx] = iNumMbAssigning;
MT_TRACE_LOG (pCtx, WELS_LOG_DEBUG, MT_TRACE_LOG (pCtx, WELS_LOG_DEBUG,
"[MT] DynamicAdjustSlicing(), uiSliceIdx= %d, pSliceComplexRatio= %.2f, slice_run_org= %d, slice_run_adj= %d\n", "[MT] DynamicAdjustSlicing(), uiSliceIdx= %d, pSliceComplexRatio= %.2f, slice_run_org= %d, slice_run_adj= %d",
iSliceIdx, pSliceComplexRatio[iSliceIdx] * 1.0f / INT_MULTIPLY, pSliceCtx->pCountMbNumInSlice[iSliceIdx], iSliceIdx, pSliceComplexRatio[iSliceIdx] * 1.0f / INT_MULTIPLY, pSliceCtx->pCountMbNumInSlice[iSliceIdx],
iNumMbAssigning); iNumMbAssigning);
++ iSliceIdx; ++ iSliceIdx;
@@ -266,7 +266,7 @@ void DynamicAdjustSlicing (sWelsEncCtx* pCtx,
} }
iRunLen[iSliceIdx] = iMbNumLeft; iRunLen[iSliceIdx] = iMbNumLeft;
MT_TRACE_LOG (pCtx, WELS_LOG_DEBUG, MT_TRACE_LOG (pCtx, WELS_LOG_DEBUG,
"[MT] DynamicAdjustSlicing(), iSliceIdx= %d, pSliceComplexRatio= %.2f, slice_run_org= %d, slice_run_adj= %d\n", "[MT] DynamicAdjustSlicing(), iSliceIdx= %d, pSliceComplexRatio= %.2f, slice_run_org= %d, slice_run_adj= %d",
iSliceIdx, pSliceComplexRatio[iSliceIdx] * 1.0f / INT_MULTIPLY, pSliceCtx->pCountMbNumInSlice[iSliceIdx], iMbNumLeft); iSliceIdx, pSliceComplexRatio[iSliceIdx] * 1.0f / INT_MULTIPLY, pSliceCtx->pCountMbNumInSlice[iSliceIdx], iMbNumLeft);
@@ -351,7 +351,7 @@ int32_t RequestMtResource (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingPara
pSmt->pFSliceDiff = fopen ("slice_time.txt", "wt+"); pSmt->pFSliceDiff = fopen ("slice_time.txt", "wt+");
#endif//MT_DEBUG #endif//MT_DEBUG
MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "encpEncCtx= 0x%p\n", (void*) *ppCtx); MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "encpEncCtx= 0x%p", (void*) *ppCtx);
char name[SEM_NAME_MAX] = {0}; char name[SEM_NAME_MAX] = {0};
WELS_GCC_UNUSED WELS_THREAD_ERROR_CODE err = 0; WELS_GCC_UNUSED WELS_THREAD_ERROR_CODE err = 0;
@@ -365,24 +365,24 @@ int32_t RequestMtResource (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingPara
WelsSnprintf (name, SEM_NAME_MAX, "ee%d%s", iIdx, pSmt->eventNamespace); WelsSnprintf (name, SEM_NAME_MAX, "ee%d%s", iIdx, pSmt->eventNamespace);
err = WelsEventOpen (&pSmt->pExitEncodeEvent[iIdx], name); err = WelsEventOpen (&pSmt->pExitEncodeEvent[iIdx], name);
MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pExitEncodeEvent%d named(%s) ret%d err%d\n", iIdx, name, err, errno); MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pExitEncodeEvent%d named(%s) ret%d err%d", iIdx, name, err, errno);
WelsSnprintf (name, SEM_NAME_MAX, "tm%d%s", iIdx, pSmt->eventNamespace); WelsSnprintf (name, SEM_NAME_MAX, "tm%d%s", iIdx, pSmt->eventNamespace);
err = WelsEventOpen (&pSmt->pThreadMasterEvent[iIdx], name); err = WelsEventOpen (&pSmt->pThreadMasterEvent[iIdx], name);
MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pThreadMasterEvent%d named(%s) ret%d err%d\n", iIdx, name, err, errno); MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pThreadMasterEvent%d named(%s) ret%d err%d", iIdx, name, err, errno);
// length of semaphore name should be system constrained at least on mac 10.7 // length of semaphore name should be system constrained at least on mac 10.7
WelsSnprintf (name, SEM_NAME_MAX, "ud%d%s", iIdx, pSmt->eventNamespace); WelsSnprintf (name, SEM_NAME_MAX, "ud%d%s", iIdx, pSmt->eventNamespace);
err = WelsEventOpen (&pSmt->pUpdateMbListEvent[iIdx], name); err = WelsEventOpen (&pSmt->pUpdateMbListEvent[iIdx], name);
MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pUpdateMbListEvent%d named(%s) ret%d err%d\n", iIdx, name, err, errno); MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pUpdateMbListEvent%d named(%s) ret%d err%d", iIdx, name, err, errno);
WelsSnprintf (name, SEM_NAME_MAX, "fu%d%s", iIdx, pSmt->eventNamespace); WelsSnprintf (name, SEM_NAME_MAX, "fu%d%s", iIdx, pSmt->eventNamespace);
err = WelsEventOpen (&pSmt->pFinUpdateMbListEvent[iIdx], name); err = WelsEventOpen (&pSmt->pFinUpdateMbListEvent[iIdx], name);
MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pFinUpdateMbListEvent%d named(%s) ret%d err%d\n", iIdx, name, err, MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pFinUpdateMbListEvent%d named(%s) ret%d err%d", iIdx, name, err,
errno); errno);
WelsSnprintf (name, SEM_NAME_MAX, "sc%d%s", iIdx, pSmt->eventNamespace); WelsSnprintf (name, SEM_NAME_MAX, "sc%d%s", iIdx, pSmt->eventNamespace);
err = WelsEventOpen (&pSmt->pSliceCodedEvent[iIdx], name); err = WelsEventOpen (&pSmt->pSliceCodedEvent[iIdx], name);
MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pSliceCodedEvent%d named(%s) ret%d err%d\n", iIdx, name, err, errno); MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pSliceCodedEvent%d named(%s) ret%d err%d", iIdx, name, err, errno);
WelsSnprintf (name, SEM_NAME_MAX, "rc%d%s", iIdx, pSmt->eventNamespace); WelsSnprintf (name, SEM_NAME_MAX, "rc%d%s", iIdx, pSmt->eventNamespace);
err = WelsEventOpen (&pSmt->pReadySliceCodingEvent[iIdx], name); err = WelsEventOpen (&pSmt->pReadySliceCodingEvent[iIdx], name);
MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pReadySliceCodingEvent%d = 0x%p named(%s) ret%d err%d\n", iIdx, MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pReadySliceCodingEvent%d = 0x%p named(%s) ret%d err%d", iIdx,
(void*)pSmt->pReadySliceCodingEvent[iIdx], name, err, errno); (void*)pSmt->pReadySliceCodingEvent[iIdx], name, err, errno);
++ iIdx; ++ iIdx;
@@ -390,7 +390,7 @@ int32_t RequestMtResource (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingPara
WelsSnprintf (name, SEM_NAME_MAX, "scm%s", pSmt->eventNamespace); WelsSnprintf (name, SEM_NAME_MAX, "scm%s", pSmt->eventNamespace);
err = WelsEventOpen (&pSmt->pSliceCodedMasterEvent, name); err = WelsEventOpen (&pSmt->pSliceCodedMasterEvent, name);
MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pSliceCodedMasterEvent named(%s) ret%d err%d\n", name, err, errno); MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "[MT] Open pSliceCodedMasterEvent named(%s) ret%d err%d", name, err, errno);
(*ppCtx)->pSliceBs = (SWelsSliceBs*)pMa->WelsMalloc (sizeof (SWelsSliceBs) * iMaxSliceNum, "pSliceBs"); (*ppCtx)->pSliceBs = (SWelsSliceBs*)pMa->WelsMalloc (sizeof (SWelsSliceBs) * iMaxSliceNum, "pSliceBs");
WELS_VERIFY_RETURN_PROC_IF (1, (NULL == (*ppCtx)->pSliceBs), FreeMemorySvc (ppCtx)) WELS_VERIFY_RETURN_PROC_IF (1, (NULL == (*ppCtx)->pSliceBs), FreeMemorySvc (ppCtx))
@@ -423,7 +423,7 @@ int32_t RequestMtResource (sWelsEncCtx** ppCtx, SWelsSvcCodingParam* pCodingPara
iReturn = WelsMutexInit (& (*ppCtx)->mutexEncoderError); iReturn = WelsMutexInit (& (*ppCtx)->mutexEncoderError);
WELS_VERIFY_RETURN_PROC_IF (1, (WELS_THREAD_ERROR_OK != iReturn), FreeMemorySvc (ppCtx)) WELS_VERIFY_RETURN_PROC_IF (1, (WELS_THREAD_ERROR_OK != iReturn), FreeMemorySvc (ppCtx))
MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "RequestMtResource(), iThreadNum=%d, iCountSliceNum= %d\n", MT_TRACE_LOG (*ppCtx, WELS_LOG_INFO, "RequestMtResource(), iThreadNum=%d, iCountSliceNum= %d",
pPara->iCountThreadsNum, pPara->iCountThreadsNum,
iMaxSliceNum); iMaxSliceNum);
@@ -707,7 +707,7 @@ WELS_THREAD_ROUTINE_TYPE CodingSliceThreadProc (void* arg) {
do { do {
MT_TRACE_LOG (pEncPEncCtx, WELS_LOG_INFO, MT_TRACE_LOG (pEncPEncCtx, WELS_LOG_INFO,
"[MT] CodingSliceThreadProc(), try to call WelsMultipleEventsWaitSingleBlocking(pEventsList= %p %p %p), pEncPEncCtx= %p!\n", "[MT] CodingSliceThreadProc(), try to call WelsMultipleEventsWaitSingleBlocking(pEventsList= %p %p %p), pEncPEncCtx= %p!",
pEventsList[0], pEventsList[1], pEventsList[1], (void*)pEncPEncCtx); pEventsList[0], pEventsList[1], pEventsList[1], (void*)pEncPEncCtx);
iWaitRet = WelsMultipleEventsWaitSingleBlocking (iEventCount, iWaitRet = WelsMultipleEventsWaitSingleBlocking (iEventCount,
&pEventsList[0], &pEventsList[0],
@@ -799,7 +799,7 @@ WELS_THREAD_ROUTINE_TYPE CodingSliceThreadProc (void* arg) {
pEncPEncCtx->pSliceThreading->pSliceConsumeTime[pEncPEncCtx->uiDependencyId][iSliceIdx] = (uint32_t) ( pEncPEncCtx->pSliceThreading->pSliceConsumeTime[pEncPEncCtx->uiDependencyId][iSliceIdx] = (uint32_t) (
WelsTime() - iSliceStart); WelsTime() - iSliceStart);
MT_TRACE_LOG (pEncPEncCtx, WELS_LOG_INFO, MT_TRACE_LOG (pEncPEncCtx, WELS_LOG_INFO,
"[MT] CodingSliceThreadProc(), coding_idx %d, uiSliceIdx %d, pSliceConsumeTime %d, iSliceSize %d, pFirstMbInSlice %d, count_num_mb_in_slice %d\n", "[MT] CodingSliceThreadProc(), coding_idx %d, uiSliceIdx %d, pSliceConsumeTime %d, iSliceSize %d, pFirstMbInSlice %d, count_num_mb_in_slice %d",
pEncPEncCtx->iCodingIndex, iSliceIdx, pEncPEncCtx->iCodingIndex, iSliceIdx,
pEncPEncCtx->pSliceThreading->pSliceConsumeTime[pEncPEncCtx->uiDependencyId][iSliceIdx], iSliceSize, pEncPEncCtx->pSliceThreading->pSliceConsumeTime[pEncPEncCtx->uiDependencyId][iSliceIdx], iSliceSize,
pCurDq->pSliceEncCtx->pFirstMbInSlice[iSliceIdx], pCurDq->pSliceEncCtx->pCountMbNumInSlice[iSliceIdx]); pCurDq->pSliceEncCtx->pFirstMbInSlice[iSliceIdx], pCurDq->pSliceEncCtx->pCountMbNumInSlice[iSliceIdx]);
@@ -941,7 +941,7 @@ WELS_THREAD_ROUTINE_TYPE CodingSliceThreadProc (void* arg) {
&pEncPEncCtx->pSliceThreading->pFinUpdateMbListEvent[iEventIdx]); // mean finished update pMb list for this pSlice &pEncPEncCtx->pSliceThreading->pFinUpdateMbListEvent[iEventIdx]); // mean finished update pMb list for this pSlice
} else { // WELS_THREAD_ERROR_WAIT_TIMEOUT, or WELS_THREAD_ERROR_WAIT_FAILED } else { // WELS_THREAD_ERROR_WAIT_TIMEOUT, or WELS_THREAD_ERROR_WAIT_FAILED
WelsLog (& (pEncPEncCtx->sLogCtx), WELS_LOG_WARNING, WelsLog (& (pEncPEncCtx->sLogCtx), WELS_LOG_WARNING,
"[MT] CodingSliceThreadProc(), waiting pReadySliceCodingEvent[%d] failed(%d) and thread%d terminated!\n", iEventIdx, "[MT] CodingSliceThreadProc(), waiting pReadySliceCodingEvent[%d] failed(%d) and thread%d terminated!", iEventIdx,
iWaitRet, iThreadIdx); iWaitRet, iThreadIdx);
uiThrdRet = 1; uiThrdRet = 1;
break; break;
@@ -966,7 +966,7 @@ int32_t CreateSliceThreads (sWelsEncCtx* pCtx) {
++ iIdx; ++ iIdx;
} }
MT_TRACE_LOG (pCtx, WELS_LOG_INFO, "CreateSliceThreads() exit..\n"); MT_TRACE_LOG (pCtx, WELS_LOG_INFO, "CreateSliceThreads() exit..");
return 0; return 0;
} }
@@ -979,7 +979,7 @@ int32_t FiredSliceThreads (sWelsEncCtx* pCtx, SSliceThreadPrivateData* pPriData,
if (pPriData == NULL || pLbi == NULL || kiEventCnt <= 0 || pEventsList == NULL) { if (pPriData == NULL || pLbi == NULL || kiEventCnt <= 0 || pEventsList == NULL) {
WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR, WelsLog (& (pCtx->sLogCtx), WELS_LOG_ERROR,
"FiredSliceThreads(), fail due pPriData == %p || pLbi == %p || iEventCnt(%d) <= 0 || pEventsList == %p!!\n", "FiredSliceThreads(), fail due pPriData == %p || pLbi == %p || iEventCnt(%d) <= 0 || pEventsList == %p!!",
(void*)pPriData, (void*)pLbi, uiNumThreads, (void*)pEventsList); (void*)pPriData, (void*)pLbi, uiNumThreads, (void*)pEventsList);
return 1; return 1;
} }

10
codec/encoder/core/src/svc_base_layer_md.cpp
View File

@@ -1134,7 +1134,7 @@ void WelsMdInterFinePartition (void* pEnc, void* pMd, SSlice* pSlice, SMB* pCurM
// SMbCache *pMbCache = &pSlice->sMbCacheInfo; // SMbCache *pMbCache = &pSlice->sMbCacheInfo;
int32_t iCost = 0; int32_t iCost = 0;
// WelsLog( pEncCtx, WELS_LOG_INFO, "WelsMdP8x8, p_ref[0]= 0x%p\n", pMbCache->SPicData.pRefMb[0]); // WelsLog( pEncCtx, WELS_LOG_INFO, "WelsMdP8x8, p_ref[0]= 0x%p", pMbCache->SPicData.pRefMb[0]);
iCost = WelsMdP8x8 (pEncCtx->pFuncList, pCurDqLayer, pWelsMd, pSlice); iCost = WelsMdP8x8 (pEncCtx->pFuncList, pCurDqLayer, pWelsMd, pSlice);
@@ -1142,7 +1142,7 @@ void WelsMdInterFinePartition (void* pEnc, void* pMd, SSlice* pSlice, SMB* pCurM
int32_t iCostPart; int32_t iCostPart;
pCurMb->uiMbType = MB_TYPE_8x8; pCurMb->uiMbType = MB_TYPE_8x8;
// WelsLog( pEncCtx, WELS_LOG_INFO, "WelsMdP16x8, p_ref[0]= 0x%p\n", pMbCache->SPicData.pRefMb[0]); // WelsLog( pEncCtx, WELS_LOG_INFO, "WelsMdP16x8, p_ref[0]= 0x%p", pMbCache->SPicData.pRefMb[0]);
iCostPart = WelsMdP16x8 (pEncCtx->pFuncList, pCurDqLayer, pWelsMd, pSlice); iCostPart = WelsMdP16x8 (pEncCtx->pFuncList, pCurDqLayer, pWelsMd, pSlice);
if (iCostPart <= iCost) { if (iCostPart <= iCost) {
iCost = iCostPart; iCost = iCostPart;
@@ -1150,7 +1150,7 @@ void WelsMdInterFinePartition (void* pEnc, void* pMd, SSlice* pSlice, SMB* pCurM
//pCurMb->mb_partition = 2; //pCurMb->mb_partition = 2;
} }
// WelsLog( pEncCtx, WELS_LOG_INFO, "WelsMdP8x16, p_ref[0]= 0x%p\n", pMbCache->SPicData.pRefMb[0]); // WelsLog( pEncCtx, WELS_LOG_INFO, "WelsMdP8x16, p_ref[0]= 0x%p", pMbCache->SPicData.pRefMb[0]);
iCostPart = WelsMdP8x16 (pEncCtx->pFuncList, pCurDqLayer, pWelsMd, pSlice); iCostPart = WelsMdP8x16 (pEncCtx->pFuncList, pCurDqLayer, pWelsMd, pSlice);
if (iCostPart <= iCost) { if (iCostPart <= iCost) {
iCost = iCostPart; iCost = iCostPart;
@@ -1178,7 +1178,7 @@ void WelsMdInterFinePartitionVaa (void* pEnc, void* pMd, SSlice* pSlice, SMB* pC
switch (uiMbSign) { switch (uiMbSign) {
case 3: case 3:
case 12: case 12:
// WelsLog( pEncCtx, WELS_LOG_INFO, "WelsMdP16x8, p_ref[0]= 0x%p\n", pMbCache->SPicData.pRefMb[0]); // WelsLog( pEncCtx, WELS_LOG_INFO, "WelsMdP16x8, p_ref[0]= 0x%p", pMbCache->SPicData.pRefMb[0]);
iCostP16x8 = WelsMdP16x8 (pEncCtx->pFuncList, pCurDqLayer, pWelsMd, pSlice); iCostP16x8 = WelsMdP16x8 (pEncCtx->pFuncList, pCurDqLayer, pWelsMd, pSlice);
if (iCostP16x8 < iBestCost) { if (iCostP16x8 < iBestCost) {
iBestCost = iCostP16x8; iBestCost = iCostP16x8;
@@ -1189,7 +1189,7 @@ void WelsMdInterFinePartitionVaa (void* pEnc, void* pMd, SSlice* pSlice, SMB* pC
case 5: case 5:
case 10: case 10:
// WelsLog( pEncCtx, WELS_LOG_INFO, "WelsMdP8x16, p_ref[0]= 0x%p\n", pMbCache->SPicData.pRefMb[0]); // WelsLog( pEncCtx, WELS_LOG_INFO, "WelsMdP8x16, p_ref[0]= 0x%p", pMbCache->SPicData.pRefMb[0]);
iCostP8x16 = WelsMdP8x16 (pEncCtx->pFuncList, pCurDqLayer, pWelsMd, pSlice); iCostP8x16 = WelsMdP8x16 (pEncCtx->pFuncList, pCurDqLayer, pWelsMd, pSlice);
if (iCostP8x16 < iBestCost) { if (iCostP8x16 < iBestCost) {
iBestCost = iCostP8x16; iBestCost = iCostP8x16;

4
codec/encoder/core/src/wels_preprocess.cpp
View File

@@ -992,7 +992,7 @@ ESceneChangeIdc CWelsPreProcess::DetectSceneChangeScreen (sWelsEncCtx* pCtx, SPi
iAvailableSceneRefNum); iAvailableSceneRefNum);
//after this build, pAvailableRefList[idx].iSrcListIdx is the idx of the ref in h->spatial_pic //after this build, pAvailableRefList[idx].iSrcListIdx is the idx of the ref in h->spatial_pic
if (0 == iAvailableRefNum) { if (0 == iAvailableRefNum) {
WelsLog (pLogCtx, WELS_LOG_ERROR, "SceneChangeDetect() iAvailableRefNum=0 but not I.\n"); WelsLog (pLogCtx, WELS_LOG_ERROR, "SceneChangeDetect() iAvailableRefNum=0 but not I.");
return LARGE_CHANGED_SCENE; return LARGE_CHANGED_SCENE;
} }
@@ -1071,7 +1071,7 @@ ESceneChangeIdc CWelsPreProcess::DetectSceneChangeScreen (sWelsEncCtx* pCtx, SPi
iVaaFrameSceneChangeIdc = SIMILAR_SCENE; iVaaFrameSceneChangeIdc = SIMILAR_SCENE;
} }
WelsLog (pLogCtx, WELS_LOG_INFO, "iVaaFrameSceneChangeIdc = %d,codingIdx = %d\n", iVaaFrameSceneChangeIdc, WelsLog (pLogCtx, WELS_LOG_INFO, "iVaaFrameSceneChangeIdc = %d,codingIdx = %d", iVaaFrameSceneChangeIdc,
pCtx->iCodingIndex); pCtx->iCodingIndex);
SaveBestRefToVaa (sLtrSaved, & (pVaaExt->sVaaStrBestRefCandidate[0])); SaveBestRefToVaa (sLtrSaved, & (pVaaExt->sVaaStrBestRefCandidate[0]));

116
codec/encoder/plus/src/welsEncoderExt.cpp
View File

@@ -131,11 +131,11 @@ CWelsH264SVCEncoder::CWelsH264SVCEncoder()
CWelsH264SVCEncoder::~CWelsH264SVCEncoder() { CWelsH264SVCEncoder::~CWelsH264SVCEncoder() {
if (m_pWelsTrace) { if (m_pWelsTrace) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "CWelsH264SVCEncoder::~CWelsH264SVCEncoder()\n"); WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "CWelsH264SVCEncoder::~CWelsH264SVCEncoder()");
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::~CWelsH264SVCEncoder(), m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", m_uiCountFrameNum, "CWelsH264SVCEncoder::~CWelsH264SVCEncoder(), m_uiCountFrameNum= %d, m_iCspInternal= 0x%x", m_uiCountFrameNum,
m_iCspInternal); m_iCspInternal);
#endif #endif
} }
@@ -177,7 +177,7 @@ void CWelsH264SVCEncoder::InitEncoder (void) {
VERSION_NUMBER); VERSION_NUMBER);
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::InitEncoder, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", m_uiCountFrameNum, m_iCspInternal); "CWelsH264SVCEncoder::InitEncoder, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x", m_uiCountFrameNum, m_iCspInternal);
#endif #endif
} }
@@ -197,7 +197,7 @@ int CWelsH264SVCEncoder::Initialize (const SEncParamBase* argv) {
} }
if (NULL == argv) { if (NULL == argv) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), invalid argv= 0x%p\n", WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), invalid argv= 0x%p",
argv); argv);
return cmInitParaError; return cmInitParaError;
} }
@@ -206,7 +206,7 @@ int CWelsH264SVCEncoder::Initialize (const SEncParamBase* argv) {
// Convert SEncParamBase into WelsSVCParamConfig here.. // Convert SEncParamBase into WelsSVCParamConfig here..
if (sConfig.ParamBaseTranscode (*argv)) { if (sConfig.ParamBaseTranscode (*argv)) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
"CWelsH264SVCEncoder::Initialize(), parameter_translation failed.\n"); "CWelsH264SVCEncoder::Initialize(), parameter_translation failed.");
Uninitialize(); Uninitialize();
return cmInitParaError; return cmInitParaError;
} }
@@ -220,7 +220,7 @@ int CWelsH264SVCEncoder::InitializeExt (const SEncParamExt* argv) {
} }
if (NULL == argv) { if (NULL == argv) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "CWelsH264SVCEncoder::InitializeExt(), invalid argv= 0x%p\n", WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "CWelsH264SVCEncoder::InitializeExt(), invalid argv= 0x%p",
argv); argv);
return cmInitParaError; return cmInitParaError;
} }
@@ -229,7 +229,7 @@ int CWelsH264SVCEncoder::InitializeExt (const SEncParamExt* argv) {
// Convert SEncParamExt into WelsSVCParamConfig here.. // Convert SEncParamExt into WelsSVCParamConfig here..
if (sConfig.ParamTranscode (*argv)) { if (sConfig.ParamTranscode (*argv)) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
"CWelsH264SVCEncoder::InitializeExt(), parameter_translation failed.\n"); "CWelsH264SVCEncoder::InitializeExt(), parameter_translation failed.");
Uninitialize(); Uninitialize();
return cmInitParaError; return cmInitParaError;
} }
@@ -239,14 +239,14 @@ int CWelsH264SVCEncoder::InitializeExt (const SEncParamExt* argv) {
int CWelsH264SVCEncoder::InitializeInternal (SWelsSvcCodingParam* pCfg) { int CWelsH264SVCEncoder::InitializeInternal (SWelsSvcCodingParam* pCfg) {
if (NULL == pCfg) { if (NULL == pCfg) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), invalid argv= 0x%p.\n", WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), invalid argv= 0x%p.",
pCfg); pCfg);
return cmInitParaError; return cmInitParaError;
} }
if (m_bInitialFlag) { if (m_bInitialFlag) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_WARNING, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_WARNING,
"CWelsH264SVCEncoder::Initialize(), reinitialize, m_bInitialFlag= %d.\n", "CWelsH264SVCEncoder::Initialize(), reinitialize, m_bInitialFlag= %d.",
m_bInitialFlag); m_bInitialFlag);
Uninitialize(); Uninitialize();
} }
@@ -254,10 +254,10 @@ int CWelsH264SVCEncoder::InitializeInternal (SWelsSvcCodingParam* pCfg) {
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
SWelsSvcCodingParam& sEncodingParam = *pCfg; SWelsSvcCodingParam& sEncodingParam = *pCfg;
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::Initialize, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", "CWelsH264SVCEncoder::Initialize, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x",
m_uiCountFrameNum, m_iCspInternal); m_uiCountFrameNum, m_iCspInternal);
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"coding_param->iPicWidth= %d;coding_param->iPicHeight= %d;coding_param->iTargetBitrate= %d;coding_param->iRCMode= %d;coding_param->iTemporalLayerNum= %d;coding_param->iSpatialLayerNum= %d;coding_param->fFrameRate= %.6ff;coding_param->iInputCsp= %d;coding_param->uiIntraPeriod= %d;coding_param->bEnableSpsPpsIdAddition = %d;coding_param->bPrefixNalAddingCtrl = %d;coding_param->bEnableDenoise= %d;coding_param->bEnableBackgroundDetection= %d;coding_param->bEnableAdaptiveQuant= %d;coding_param->bEnableFrameSkip= %d;coding_param->bEnableCropPic= %d;coding_param->bEnableLongTermReference= %d;coding_param->iLtrMarkPeriod= %d;\n", "coding_param->iPicWidth= %d;coding_param->iPicHeight= %d;coding_param->iTargetBitrate= %d;coding_param->iRCMode= %d;coding_param->iTemporalLayerNum= %d;coding_param->iSpatialLayerNum= %d;coding_param->fFrameRate= %.6ff;coding_param->iInputCsp= %d;coding_param->uiIntraPeriod= %d;coding_param->bEnableSpsPpsIdAddition = %d;coding_param->bPrefixNalAddingCtrl = %d;coding_param->bEnableDenoise= %d;coding_param->bEnableBackgroundDetection= %d;coding_param->bEnableAdaptiveQuant= %d;coding_param->bEnableFrameSkip= %d;coding_param->bEnableCropPic= %d;coding_param->bEnableLongTermReference= %d;coding_param->iLtrMarkPeriod= %d;",
sEncodingParam.iPicWidth, sEncodingParam.iPicWidth,
sEncodingParam.iPicHeight, sEncodingParam.iPicHeight,
sEncodingParam.iTargetBitrate, sEncodingParam.iTargetBitrate,
@@ -280,7 +280,7 @@ int CWelsH264SVCEncoder::InitializeInternal (SWelsSvcCodingParam* pCfg) {
while (i < sEncodingParam.iSpatialLayerNum) { while (i < sEncodingParam.iSpatialLayerNum) {
SSpatialLayerConfig* spatial_cfg = &sEncodingParam.sSpatialLayers[i]; SSpatialLayerConfig* spatial_cfg = &sEncodingParam.sSpatialLayers[i];
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"coding_param->sSpatialLayers[%d]: .iVideoWidth= %d; .iVideoHeight= %d; .fFrameRate= %.6ff; .iSpatialBitrate= %d; .sSliceCfg.uiSliceMode= %d; .sSliceCfg.sSliceArgument.uiSliceNum= %d; .sSliceCfg.sSliceArgument.uiSliceSizeConstraint= %d;\n", "coding_param->sSpatialLayers[%d]: .iVideoWidth= %d; .iVideoHeight= %d; .fFrameRate= %.6ff; .iSpatialBitrate= %d; .sSliceCfg.uiSliceMode= %d; .sSliceCfg.sSliceArgument.uiSliceNum= %d; .sSliceCfg.sSliceArgument.uiSliceSizeConstraint= %d;",
i, spatial_cfg->iVideoWidth, i, spatial_cfg->iVideoWidth,
spatial_cfg->iVideoHeight, spatial_cfg->iVideoHeight,
spatial_cfg->fFrameRate, spatial_cfg->fFrameRate,
@@ -297,7 +297,7 @@ int CWelsH264SVCEncoder::InitializeInternal (SWelsSvcCodingParam* pCfg) {
const int32_t iNumOfLayers = pCfg->iSpatialLayerNum; const int32_t iNumOfLayers = pCfg->iSpatialLayerNum;
if (iNumOfLayers < 1 || iNumOfLayers > MAX_DEPENDENCY_LAYER) { if (iNumOfLayers < 1 || iNumOfLayers > MAX_DEPENDENCY_LAYER) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
"CWelsH264SVCEncoder::Initialize(), invalid iSpatialLayerNum= %d, valid at range of [1, %d].\n", iNumOfLayers, "CWelsH264SVCEncoder::Initialize(), invalid iSpatialLayerNum= %d, valid at range of [1, %d].", iNumOfLayers,
MAX_DEPENDENCY_LAYER); MAX_DEPENDENCY_LAYER);
Uninitialize(); Uninitialize();
return cmInitParaError; return cmInitParaError;
@@ -306,7 +306,7 @@ int CWelsH264SVCEncoder::InitializeInternal (SWelsSvcCodingParam* pCfg) {
pCfg->iTemporalLayerNum = 1; pCfg->iTemporalLayerNum = 1;
if (pCfg->iTemporalLayerNum > MAX_TEMPORAL_LEVEL) { if (pCfg->iTemporalLayerNum > MAX_TEMPORAL_LEVEL) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
"CWelsH264SVCEncoder::Initialize(), invalid iTemporalLayerNum= %d, valid at range of [1, %d].\n", "CWelsH264SVCEncoder::Initialize(), invalid iTemporalLayerNum= %d, valid at range of [1, %d].",
pCfg->iTemporalLayerNum, MAX_TEMPORAL_LEVEL); pCfg->iTemporalLayerNum, MAX_TEMPORAL_LEVEL);
Uninitialize(); Uninitialize();
return cmInitParaError; return cmInitParaError;
@@ -316,7 +316,7 @@ int CWelsH264SVCEncoder::InitializeInternal (SWelsSvcCodingParam* pCfg) {
if (pCfg->uiGopSize < 1 || pCfg->uiGopSize > MAX_GOP_SIZE) { if (pCfg->uiGopSize < 1 || pCfg->uiGopSize > MAX_GOP_SIZE) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
"CWelsH264SVCEncoder::Initialize(), invalid uiGopSize= %d, valid at range of [1, %d].\n", pCfg->uiGopSize, "CWelsH264SVCEncoder::Initialize(), invalid uiGopSize= %d, valid at range of [1, %d].", pCfg->uiGopSize,
MAX_GOP_SIZE); MAX_GOP_SIZE);
Uninitialize(); Uninitialize();
return cmInitParaError; return cmInitParaError;
@@ -324,7 +324,7 @@ int CWelsH264SVCEncoder::InitializeInternal (SWelsSvcCodingParam* pCfg) {
if (!WELS_POWER2_IF (pCfg->uiGopSize)) { if (!WELS_POWER2_IF (pCfg->uiGopSize)) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
"CWelsH264SVCEncoder::Initialize(), invalid uiGopSize= %d, valid at range of [1, %d] and yield to power of 2.\n", "CWelsH264SVCEncoder::Initialize(), invalid uiGopSize= %d, valid at range of [1, %d] and yield to power of 2.",
pCfg->uiGopSize, MAX_GOP_SIZE); pCfg->uiGopSize, MAX_GOP_SIZE);
Uninitialize(); Uninitialize();
return cmInitParaError; return cmInitParaError;
@@ -332,7 +332,7 @@ int CWelsH264SVCEncoder::InitializeInternal (SWelsSvcCodingParam* pCfg) {
if (pCfg->uiIntraPeriod && pCfg->uiIntraPeriod < pCfg->uiGopSize) { if (pCfg->uiIntraPeriod && pCfg->uiIntraPeriod < pCfg->uiGopSize) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
"CWelsH264SVCEncoder::Initialize(), invalid uiIntraPeriod= %d, valid in case it equals to 0 for unlimited intra period or exceeds specified uiGopSize= %d.\n", "CWelsH264SVCEncoder::Initialize(), invalid uiIntraPeriod= %d, valid in case it equals to 0 for unlimited intra period or exceeds specified uiGopSize= %d.",
pCfg->uiIntraPeriod, pCfg->uiGopSize); pCfg->uiIntraPeriod, pCfg->uiGopSize);
Uninitialize(); Uninitialize();
return cmInitParaError; return cmInitParaError;
@@ -340,7 +340,7 @@ int CWelsH264SVCEncoder::InitializeInternal (SWelsSvcCodingParam* pCfg) {
if ((pCfg->uiIntraPeriod && (pCfg->uiIntraPeriod & (pCfg->uiGopSize - 1)) != 0)) { if ((pCfg->uiIntraPeriod && (pCfg->uiIntraPeriod & (pCfg->uiGopSize - 1)) != 0)) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
"CWelsH264SVCEncoder::Initialize(), invalid uiIntraPeriod= %d, valid in case it equals to 0 for unlimited intra period or exceeds specified uiGopSize= %d also multiple of it.\n", "CWelsH264SVCEncoder::Initialize(), invalid uiIntraPeriod= %d, valid in case it equals to 0 for unlimited intra period or exceeds specified uiGopSize= %d also multiple of it.",
pCfg->uiIntraPeriod, pCfg->uiGopSize); pCfg->uiIntraPeriod, pCfg->uiGopSize);
Uninitialize(); Uninitialize();
return cmInitParaError; return cmInitParaError;
@@ -379,7 +379,7 @@ int CWelsH264SVCEncoder::InitializeInternal (SWelsSvcCodingParam* pCfg) {
m_iMaxPicHeight = pCfg->iPicHeight; m_iMaxPicHeight = pCfg->iPicHeight;
if (WelsInitEncoderExt (&m_pEncContext, pCfg, &m_pWelsTrace->m_sLogCtx)) { if (WelsInitEncoderExt (&m_pEncContext, pCfg, &m_pWelsTrace->m_sLogCtx)) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), WelsInitEncoderExt failed.\n"); WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "CWelsH264SVCEncoder::Initialize(), WelsInitEncoderExt failed.");
Uninitialize(); Uninitialize();
return cmInitParaError; return cmInitParaError;
} }
@@ -397,11 +397,11 @@ int32_t CWelsH264SVCEncoder::Uninitialize() {
return 0; return 0;
} }
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "CWelsH264SVCEncoder::Uninitialize()..\n"); WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "CWelsH264SVCEncoder::Uninitialize()..");
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::Uninitialize, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", m_uiCountFrameNum, m_iCspInternal); "CWelsH264SVCEncoder::Uninitialize, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x", m_uiCountFrameNum, m_iCspInternal);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
if (NULL != m_pEncContext) { if (NULL != m_pEncContext) {
@@ -433,7 +433,7 @@ int CWelsH264SVCEncoder::EncodeFrame (const SSourcePicture* kpSrcPic, SFrameBSIn
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
++ m_uiCountFrameNum; ++ m_uiCountFrameNum;
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::EncodeFrame(), m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", m_uiCountFrameNum, m_iCspInternal); "CWelsH264SVCEncoder::EncodeFrame(), m_uiCountFrameNum= %d, m_iCspInternal= 0x%x", m_uiCountFrameNum, m_iCspInternal);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
#ifdef DUMP_SRC_PICTURE #ifdef DUMP_SRC_PICTURE
@@ -450,7 +450,7 @@ int CWelsH264SVCEncoder::EncodeFrameInternal (const SSourcePicture* pSrcPic, SF
WelsUninitEncoderExt (&m_pEncContext); WelsUninitEncoderExt (&m_pEncContext);
return cmMallocMemeError; return cmMallocMemeError;
} else if ((kiEncoderReturn != ENC_RETURN_SUCCESS) && (kiEncoderReturn == ENC_RETURN_CORRECTED)) { } else if ((kiEncoderReturn != ENC_RETURN_SUCCESS) && (kiEncoderReturn == ENC_RETURN_CORRECTED)) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "unexpected return(%d) from EncodeFrameInternal()!\n", WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, "unexpected return(%d) from EncodeFrameInternal()!",
kiEncoderReturn); kiEncoderReturn);
return cmUnkonwReason; return cmUnkonwReason;
} }
@@ -519,7 +519,7 @@ int CWelsH264SVCEncoder::ForceIntraFrame (bool bIDR) {
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::ForceIntraFrame(), bIDR= %d, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", bIDR, "CWelsH264SVCEncoder::ForceIntraFrame(), bIDR= %d, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x", bIDR,
m_uiCountFrameNum, m_iCspInternal); m_uiCountFrameNum, m_iCspInternal);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
@@ -532,13 +532,13 @@ void CWelsH264SVCEncoder::CheckProfileSetting (int32_t iLayer, EProfileIdc uiPro
pLayerInfo->uiProfileIdc = uiProfileIdc; pLayerInfo->uiProfileIdc = uiProfileIdc;
if ((iLayer == SPATIAL_LAYER_0) && (uiProfileIdc != PRO_BASELINE)) { if ((iLayer == SPATIAL_LAYER_0) && (uiProfileIdc != PRO_BASELINE)) {
pLayerInfo->uiProfileIdc = PRO_BASELINE; pLayerInfo->uiProfileIdc = PRO_BASELINE;
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_WARNING, "doesn't support profile(%d),change to baseline profile\n", WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_WARNING, "doesn't support profile(%d),change to baseline profile",
uiProfileIdc); uiProfileIdc);
} }
if (iLayer > SPATIAL_LAYER_0) { if (iLayer > SPATIAL_LAYER_0) {
if ((uiProfileIdc != PRO_BASELINE) || (uiProfileIdc != PRO_SCALABLE_BASELINE)) { if ((uiProfileIdc != PRO_BASELINE) || (uiProfileIdc != PRO_SCALABLE_BASELINE)) {
pLayerInfo->uiProfileIdc = PRO_BASELINE; pLayerInfo->uiProfileIdc = PRO_BASELINE;
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_WARNING, "doesn't support profile(%d),change to baseline profile\n", WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_WARNING, "doesn't support profile(%d),change to baseline profile",
uiProfileIdc); uiProfileIdc);
} }
} }
@@ -548,7 +548,7 @@ void CWelsH264SVCEncoder::CheckLevelSetting (int32_t iLayer, ELevelIdc uiLevelId
pLayerInfo->uiLevelIdc = uiLevelIdc; pLayerInfo->uiLevelIdc = uiLevelIdc;
if ((uiLevelIdc < LEVEL_1_0) || (uiLevelIdc > LEVEL_5_2)) { if ((uiLevelIdc < LEVEL_1_0) || (uiLevelIdc > LEVEL_5_2)) {
pLayerInfo->uiLevelIdc = LEVEL_5_2; pLayerInfo->uiLevelIdc = LEVEL_5_2;
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_WARNING, "doesn't support level(%d) change to LEVEL_5_2\n", uiLevelIdc); WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_WARNING, "doesn't support level(%d) change to LEVEL_5_2", uiLevelIdc);
} }
} }
void CWelsH264SVCEncoder::CheckReferenceNumSetting (int32_t iNumRef) { void CWelsH264SVCEncoder::CheckReferenceNumSetting (int32_t iNumRef) {
@@ -556,7 +556,7 @@ void CWelsH264SVCEncoder::CheckReferenceNumSetting (int32_t iNumRef) {
if ((iNumRef < MIN_REF_PIC_COUNT) || (iNumRef > MAX_REFERENCE_PICTURE_COUNT_NUM)) { if ((iNumRef < MIN_REF_PIC_COUNT) || (iNumRef > MAX_REFERENCE_PICTURE_COUNT_NUM)) {
m_pEncContext->pSvcParam->iNumRefFrame = AUTO_REF_PIC_COUNT; m_pEncContext->pSvcParam->iNumRefFrame = AUTO_REF_PIC_COUNT;
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_WARNING, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_WARNING,
"doesn't support the number of reference frame(%d) change to auto select mode\n", iNumRef); "doesn't support the number of reference frame(%d) change to auto select mode", iNumRef);
} }
} }
/************************************************************************ /************************************************************************
@@ -575,7 +575,7 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
switch (eOptionId) { switch (eOptionId) {
case ENCODER_OPTION_INTER_SPATIAL_PRED: { // Inter spatial layer prediction flag case ENCODER_OPTION_INTER_SPATIAL_PRED: { // Inter spatial layer prediction flag
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"ENCODER_OPTION_INTER_SPATIAL_PRED, this feature not supported at present.\n"); "ENCODER_OPTION_INTER_SPATIAL_PRED, this feature not supported at present.");
} }
break; break;
case ENCODER_OPTION_DATAFORMAT: { // Input color space case ENCODER_OPTION_DATAFORMAT: { // Input color space
@@ -587,14 +587,14 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_DATAFORMAT, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x, iValue= %d\n", "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_DATAFORMAT, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x, iValue= %d",
m_uiCountFrameNum, m_iCspInternal, iValue); m_uiCountFrameNum, m_iCspInternal, iValue);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
m_iCspInternal = iColorspace; m_iCspInternal = iColorspace;
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_DATAFORMAT, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_DATAFORMAT, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x",
m_uiCountFrameNum, m_iCspInternal); m_uiCountFrameNum, m_iCspInternal);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
} }
@@ -603,7 +603,7 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
int32_t iValue = * ((int32_t*)pOption); int32_t iValue = * ((int32_t*)pOption);
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_IDR_INTERVAL, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x, iValue= %d\n", "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_IDR_INTERVAL, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x, iValue= %d",
m_uiCountFrameNum, m_iCspInternal, iValue); m_uiCountFrameNum, m_iCspInternal, iValue);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
@@ -625,7 +625,7 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
memcpy (&sEncodingParam, pOption, sizeof (SEncParamExt)); // confirmed_safe_unsafe_usage memcpy (&sEncodingParam, pOption, sizeof (SEncParamExt)); // confirmed_safe_unsafe_usage
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"coding_param->iPicWidth= %d;coding_param->iPicHeight= %d;coding_param->iTargetBitrate= %d; coding_param->iMaxBitrate= %d; coding_param->iRCMode= %d;coding_param->iPaddingFlag= %d;coding_param->iTemporalLayerNum= %d;coding_param->iSpatialLayerNum= %d;coding_param->fFrameRate= %.6ff;coding_param->uiIntraPeriod= %d;coding_param->bEnableSpsPpsIdAddition = %d;coding_param->bPrefixNalAddingCtrl = %d;coding_param->bEnableDenoise= %d;coding_param->bEnableBackgroundDetection= %d;coding_param->bEnableAdaptiveQuant= %d;coding_param->bEnableAdaptiveQuant= %d;coding_param->bEnableLongTermReference= %d;coding_param->iLtrMarkPeriod= %d;\n", "coding_param->iPicWidth= %d;coding_param->iPicHeight= %d;coding_param->iTargetBitrate= %d; coding_param->iMaxBitrate= %d; coding_param->iRCMode= %d;coding_param->iPaddingFlag= %d;coding_param->iTemporalLayerNum= %d;coding_param->iSpatialLayerNum= %d;coding_param->fFrameRate= %.6ff;coding_param->uiIntraPeriod= %d;coding_param->bEnableSpsPpsIdAddition = %d;coding_param->bPrefixNalAddingCtrl = %d;coding_param->bEnableDenoise= %d;coding_param->bEnableBackgroundDetection= %d;coding_param->bEnableAdaptiveQuant= %d;coding_param->bEnableAdaptiveQuant= %d;coding_param->bEnableLongTermReference= %d;coding_param->iLtrMarkPeriod= %d;",
sEncodingParam.iPicWidth, sEncodingParam.iPicWidth,
sEncodingParam.iPicHeight, sEncodingParam.iPicHeight,
sEncodingParam.iTargetBitrate, sEncodingParam.iTargetBitrate,
@@ -648,7 +648,7 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
while (i < sEncodingParam.iSpatialLayerNum) { while (i < sEncodingParam.iSpatialLayerNum) {
SSpatialLayerConfig* pSpatialCfg = &sEncodingParam.sSpatialLayers[i]; SSpatialLayerConfig* pSpatialCfg = &sEncodingParam.sSpatialLayers[i];
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"coding_param->sSpatialLayers[%d]: .iVideoWidth= %d; .iVideoHeight= %d; .fFrameRate= %.6ff; .iSpatialBitrate= %d; .iMaxSpatialBitrate= %d; .sSliceCfg.uiSliceMode= %d; .sSliceCfg.sSliceArgument.iSliceNum= %d; .sSliceCfg.sSliceArgument.uiSliceSizeConstraint= %d;\n", "coding_param->sSpatialLayers[%d]: .iVideoWidth= %d; .iVideoHeight= %d; .fFrameRate= %.6ff; .iSpatialBitrate= %d; .iMaxSpatialBitrate= %d; .sSliceCfg.uiSliceMode= %d; .sSliceCfg.sSliceArgument.iSliceNum= %d; .sSliceCfg.sSliceArgument.uiSliceSizeConstraint= %d;",
i, pSpatialCfg->iVideoWidth, i, pSpatialCfg->iVideoWidth,
pSpatialCfg->iVideoHeight, pSpatialCfg->iVideoHeight,
pSpatialCfg->fFrameRate, pSpatialCfg->fFrameRate,
@@ -687,7 +687,7 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
} }
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x",
m_uiCountFrameNum, m_iCspInternal); m_uiCountFrameNum, m_iCspInternal);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
@@ -702,7 +702,7 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
float iValue = * ((float*)pOption); float iValue = * ((float*)pOption);
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_FRAME_RATE, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x, iValue= %f\n", "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_FRAME_RATE, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x, iValue= %f",
m_uiCountFrameNum, m_iCspInternal, iValue); m_uiCountFrameNum, m_iCspInternal, iValue);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
if (iValue <= 0) { if (iValue <= 0) {
@@ -718,12 +718,12 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
int32_t iBitrate = pInfo->iBitrate; int32_t iBitrate = pInfo->iBitrate;
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_BITRATE, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x, iValue= %d\n", "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_BITRATE, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x, iValue= %d",
m_uiCountFrameNum, m_iCspInternal, iValue); m_uiCountFrameNum, m_iCspInternal, iValue);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
if (iBitrate <= 0) { if (iBitrate <= 0) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_BITRATE,iBitrate = %d\n", "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_BITRATE,iBitrate = %d",
iBitrate); iBitrate);
return cmInitParaError; return cmInitParaError;
} }
@@ -746,7 +746,7 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
break; break;
default: default:
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_BITRATE,iLayer = %d\n", "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_BITRATE,iLayer = %d",
pInfo->iLayer); pInfo->iLayer);
return cmInitParaError; return cmInitParaError;
break; break;
@@ -761,12 +761,12 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_BITRATE, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x, iValue= %d\n", "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_BITRATE, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x, iValue= %d",
m_uiCountFrameNum, m_iCspInternal, iValue); m_uiCountFrameNum, m_iCspInternal, iValue);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
if (iBitrate <= 0) { if (iBitrate <= 0) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_MAX_BITRATE,iBitrate = %d\n", "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_MAX_BITRATE,iBitrate = %d",
iBitrate); iBitrate);
return cmInitParaError; return cmInitParaError;
} }
@@ -789,7 +789,7 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
break; break;
default: default:
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_MAX_BITRATE,iLayer = %d\n", "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_MAX_BITRATE,iLayer = %d",
pInfo->iLayer); pInfo->iLayer);
return cmInitParaError; return cmInitParaError;
break; break;
@@ -831,14 +831,14 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
case ENCODER_OPTION_ENABLE_SSEI: { case ENCODER_OPTION_ENABLE_SSEI: {
bool iValue = * ((bool*)pOption); bool iValue = * ((bool*)pOption);
m_pEncContext->pSvcParam->bEnableSSEI = iValue; m_pEncContext->pSvcParam->bEnableSSEI = iValue;
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, " CWelsH264SVCEncoder::SetOption enable SSEI = %d \n", WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, " CWelsH264SVCEncoder::SetOption enable SSEI = %d ",
m_pEncContext->pSvcParam->bEnableSSEI); m_pEncContext->pSvcParam->bEnableSSEI);
} }
break; break;
case ENCODER_OPTION_ENABLE_PREFIX_NAL_ADDING: { case ENCODER_OPTION_ENABLE_PREFIX_NAL_ADDING: {
bool iValue = * ((bool*)pOption); bool iValue = * ((bool*)pOption);
m_pEncContext->pSvcParam->bPrefixNalAddingCtrl = iValue; m_pEncContext->pSvcParam->bPrefixNalAddingCtrl = iValue;
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, " CWelsH264SVCEncoder::SetOption bPrefixNalAddingCtrl = %d \n", WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, " CWelsH264SVCEncoder::SetOption bPrefixNalAddingCtrl = %d ",
m_pEncContext->pSvcParam->bPrefixNalAddingCtrl); m_pEncContext->pSvcParam->bPrefixNalAddingCtrl);
} }
break; break;
@@ -846,7 +846,7 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
bool iValue = * ((bool*)pOption); bool iValue = * ((bool*)pOption);
m_pEncContext->pSvcParam->bEnableSpsPpsIdAddition = iValue; m_pEncContext->pSvcParam->bEnableSpsPpsIdAddition = iValue;
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, " CWelsH264SVCEncoder::SetOption enable SPS/PPS ID = %d \n", WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, " CWelsH264SVCEncoder::SetOption enable SPS/PPS ID = %d ",
m_pEncContext->pSvcParam->bEnableSpsPpsIdAddition); m_pEncContext->pSvcParam->bEnableSpsPpsIdAddition);
} }
break; break;
@@ -892,7 +892,7 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
SProfileInfo* pProfileInfo = (static_cast<SProfileInfo*> (pOption)); SProfileInfo* pProfileInfo = (static_cast<SProfileInfo*> (pOption));
if ((pProfileInfo->iLayer < SPATIAL_LAYER_0) || (pProfileInfo->iLayer > SPATIAL_LAYER_3)) { if ((pProfileInfo->iLayer < SPATIAL_LAYER_0) || (pProfileInfo->iLayer > SPATIAL_LAYER_3)) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_PROFILE,iLayer = %d(rang0-3)\n", pProfileInfo->iLayer); "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_PROFILE,iLayer = %d(rang0-3)", pProfileInfo->iLayer);
return cmInitParaError; return cmInitParaError;
} }
CheckProfileSetting (pProfileInfo->iLayer, pProfileInfo->uiProfileIdc); CheckProfileSetting (pProfileInfo->iLayer, pProfileInfo->uiProfileIdc);
@@ -902,7 +902,7 @@ int CWelsH264SVCEncoder::SetOption (ENCODER_OPTION eOptionId, void* pOption) {
SLevelInfo* pLevelInfo = (static_cast<SLevelInfo*> (pOption)); SLevelInfo* pLevelInfo = (static_cast<SLevelInfo*> (pOption));
if ((pLevelInfo->iLayer < SPATIAL_LAYER_0) || (pLevelInfo->iLayer > SPATIAL_LAYER_3)) { if ((pLevelInfo->iLayer < SPATIAL_LAYER_0) || (pLevelInfo->iLayer > SPATIAL_LAYER_3)) {
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_ERROR,
"CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_PROFILE,iLayer = %d(rang0-3)\n", pLevelInfo->iLayer); "CWelsH264SVCEncoder::SetOption():ENCODER_OPTION_PROFILE,iLayer = %d(rang0-3)", pLevelInfo->iLayer);
return cmInitParaError; return cmInitParaError;
} }
CheckLevelSetting (pLevelInfo->iLayer, pLevelInfo->uiLevelIdc); CheckLevelSetting (pLevelInfo->iLayer, pLevelInfo->uiLevelIdc);
@@ -941,13 +941,13 @@ int CWelsH264SVCEncoder::GetOption (ENCODER_OPTION eOptionId, void* pOption) {
switch (eOptionId) { switch (eOptionId) {
case ENCODER_OPTION_INTER_SPATIAL_PRED: { // Inter spatial layer prediction flag case ENCODER_OPTION_INTER_SPATIAL_PRED: { // Inter spatial layer prediction flag
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"ENCODER_OPTION_INTER_SPATIAL_PRED, this feature not supported at present.\n"); "ENCODER_OPTION_INTER_SPATIAL_PRED, this feature not supported at present.");
} }
break; break;
case ENCODER_OPTION_DATAFORMAT: { // Input color space case ENCODER_OPTION_DATAFORMAT: { // Input color space
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::GetOption():ENCODER_OPTION_DATAFORMAT, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", "CWelsH264SVCEncoder::GetOption():ENCODER_OPTION_DATAFORMAT, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x",
m_uiCountFrameNum, m_iCspInternal); m_uiCountFrameNum, m_iCspInternal);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
@@ -957,7 +957,7 @@ int CWelsH264SVCEncoder::GetOption (ENCODER_OPTION eOptionId, void* pOption) {
case ENCODER_OPTION_IDR_INTERVAL: { // IDR Interval case ENCODER_OPTION_IDR_INTERVAL: { // IDR Interval
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::GetOption():ENCODER_OPTION_IDR_INTERVAL, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", "CWelsH264SVCEncoder::GetOption():ENCODER_OPTION_IDR_INTERVAL, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x",
m_uiCountFrameNum, m_iCspInternal); m_uiCountFrameNum, m_iCspInternal);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
* ((int32_t*)pOption) = m_pEncContext->pSvcParam->uiIntraPeriod; * ((int32_t*)pOption) = m_pEncContext->pSvcParam->uiIntraPeriod;
@@ -966,7 +966,7 @@ int CWelsH264SVCEncoder::GetOption (ENCODER_OPTION eOptionId, void* pOption) {
case ENCODER_OPTION_SVC_ENCODE_PARAM_EXT: { // SVC Encoding Parameter case ENCODER_OPTION_SVC_ENCODE_PARAM_EXT: { // SVC Encoding Parameter
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::GetOption():ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", "CWelsH264SVCEncoder::GetOption():ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x",
m_uiCountFrameNum, m_iCspInternal); m_uiCountFrameNum, m_iCspInternal);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
memcpy (pOption, m_pEncContext->pSvcParam, sizeof (SEncParamExt)); // confirmed_safe_unsafe_usage memcpy (pOption, m_pEncContext->pSvcParam, sizeof (SEncParamExt)); // confirmed_safe_unsafe_usage
@@ -975,7 +975,7 @@ int CWelsH264SVCEncoder::GetOption (ENCODER_OPTION eOptionId, void* pOption) {
case ENCODER_OPTION_SVC_ENCODE_PARAM_BASE: { // SVC Encoding Parameter case ENCODER_OPTION_SVC_ENCODE_PARAM_BASE: { // SVC Encoding Parameter
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::GetOption():ENCODER_OPTION_SVC_ENCODE_PARAM_BASE, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", "CWelsH264SVCEncoder::GetOption():ENCODER_OPTION_SVC_ENCODE_PARAM_BASE, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x",
m_uiCountFrameNum, m_iCspInternal); m_uiCountFrameNum, m_iCspInternal);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
m_pEncContext->pSvcParam->GetBaseParams ((SEncParamBase*) pOption); m_pEncContext->pSvcParam->GetBaseParams ((SEncParamBase*) pOption);
@@ -985,7 +985,7 @@ int CWelsH264SVCEncoder::GetOption (ENCODER_OPTION eOptionId, void* pOption) {
case ENCODER_OPTION_FRAME_RATE: { // Maximal input frame rate case ENCODER_OPTION_FRAME_RATE: { // Maximal input frame rate
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::GetOption():ENCODER_OPTION_FRAME_RATE, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", "CWelsH264SVCEncoder::GetOption():ENCODER_OPTION_FRAME_RATE, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x",
m_uiCountFrameNum, m_iCspInternal); m_uiCountFrameNum, m_iCspInternal);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
* ((float*)pOption) = m_pEncContext->pSvcParam->fMaxFrameRate; * ((float*)pOption) = m_pEncContext->pSvcParam->fMaxFrameRate;
@@ -994,7 +994,7 @@ int CWelsH264SVCEncoder::GetOption (ENCODER_OPTION eOptionId, void* pOption) {
case ENCODER_OPTION_BITRATE: { // Target bit-rate case ENCODER_OPTION_BITRATE: { // Target bit-rate
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::GetOption():ENCODER_OPTION_BITRATE, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", "CWelsH264SVCEncoder::GetOption():ENCODER_OPTION_BITRATE, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x",
m_uiCountFrameNum, m_iCspInternal); m_uiCountFrameNum, m_iCspInternal);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
SBitrateInfo* pInfo = (static_cast<SBitrateInfo*> (pOption)); SBitrateInfo* pInfo = (static_cast<SBitrateInfo*> (pOption));
@@ -1011,7 +1011,7 @@ int CWelsH264SVCEncoder::GetOption (ENCODER_OPTION eOptionId, void* pOption) {
case ENCODER_OPTION_MAX_BITRATE: { // Target bit-rate case ENCODER_OPTION_MAX_BITRATE: { // Target bit-rate
#ifdef REC_FRAME_COUNT #ifdef REC_FRAME_COUNT
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO,
"CWelsH264SVCEncoder::GetOption():ENCODER_OPTION_MAX_BITRATE, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x\n", "CWelsH264SVCEncoder::GetOption():ENCODER_OPTION_MAX_BITRATE, m_uiCountFrameNum= %d, m_iCspInternal= 0x%x",
m_uiCountFrameNum, m_iCspInternal); m_uiCountFrameNum, m_iCspInternal);
#endif//REC_FRAME_COUNT #endif//REC_FRAME_COUNT
SBitrateInfo* pInfo = (static_cast<SBitrateInfo*> (pOption)); SBitrateInfo* pInfo = (static_cast<SBitrateInfo*> (pOption));
@@ -1057,7 +1057,7 @@ void CWelsH264SVCEncoder::DumpSrcPicture (const uint8_t* pSrc) {
case videoFormatYV12: case videoFormatYV12:
WelsStrcat (strFileName, 256, "yuv"); // confirmed_safe_unsafe_usage WelsStrcat (strFileName, 256, "yuv"); // confirmed_safe_unsafe_usage
pFile = WelsFopen (strFileName, "ab+"); pFile = WelsFopen (strFileName, "ab+");
// WelsLog( &m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "WELS_CSP_I420, m_iCspInternal= 0x%x\n", m_iCspInternal); // WelsLog( &m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "WELS_CSP_I420, m_iCspInternal= 0x%x", m_iCspInternal);
if (NULL != pFile) { if (NULL != pFile) {
fwrite (pSrc, sizeof (uint8_t), (iDataLength * 3) >> 1, pFile); fwrite (pSrc, sizeof (uint8_t), (iDataLength * 3) >> 1, pFile);
fflush (pFile); fflush (pFile);
@@ -1075,7 +1075,7 @@ void CWelsH264SVCEncoder::DumpSrcPicture (const uint8_t* pSrc) {
case videoFormatBGR: case videoFormatBGR:
WelsStrcat (strFileName, 256, "bgr"); // confirmed_safe_unsafe_usage WelsStrcat (strFileName, 256, "bgr"); // confirmed_safe_unsafe_usage
pFile = WelsFopen (strFileName, "ab+"); pFile = WelsFopen (strFileName, "ab+");
// WelsLog( &m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "WELS_CSP_BGR, m_iCspInternal= 0x%x\n", m_iCspInternal); // WelsLog( &m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "WELS_CSP_BGR, m_iCspInternal= 0x%x", m_iCspInternal);
if (NULL != pFile) { if (NULL != pFile) {
fwrite (pSrc, sizeof (uint8_t), iDataLength * 3, pFile); fwrite (pSrc, sizeof (uint8_t), iDataLength * 3, pFile);
fflush (pFile); fflush (pFile);
@@ -1092,7 +1092,7 @@ void CWelsH264SVCEncoder::DumpSrcPicture (const uint8_t* pSrc) {
} }
break; break;
default: default:
WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "Exclusive case, m_iCspInternal= 0x%x\n", m_iCspInternal); WelsLog (&m_pWelsTrace->m_sLogCtx, WELS_LOG_INFO, "Exclusive case, m_iCspInternal= 0x%x", m_iCspInternal);
break; break;
} }
#endif//DUMP_SRC_PICTURE #endif//DUMP_SRC_PICTURE