History

1. add Tid API UT 2. add Trace UT 3. Fix a crash issue when set NULL trace

dongzha committed 12 years ago

Commit c213c6b1 parent 8538b222 files · +472 −2Browse files

Showing the changes to test/api/encode_decode_api_test.cpp (1 of 2 files). Show all

Unified · Split

test/api/encode_decode_api_test.cpp+469−0
@@ -25,12 +25,31 @@ struct EncodeDecodeFileParamBase { · 24 unmodified lines
2525 const char* pLossSequence;
2626 };
2727
28+static void welsStderrTraceOrigin (void* ctx, int level, const char* string) {
29+ fprintf (stderr, "%s\n", string);
30+}
31+
32+typedef struct STrace_Unit {
33+ int iTarLevel;
34+} STraceUnit;
35+
36+static void TestOutPutTrace (void* ctx, int level, const char* string) {
37+ STraceUnit* pTraceUnit = (STraceUnit*) ctx;
38+ EXPECT_LE (level, pTraceUnit->iTarLevel);
39+}
40+
2841 class EncodeDecodeTestBase : public ::testing::TestWithParam<EncodeDecodeFileParamBase>,
2942 public BaseEncoderTest, public BaseDecoderTest {
3043 public:
3144 virtual void SetUp() {
3245 BaseEncoderTest::SetUp();
3346 BaseDecoderTest::SetUp();
47+ pFunc = welsStderrTraceOrigin;
48+ pTraceInfo = NULL;
49+ encoder_->SetOption (ENCODER_OPTION_TRACE_CALLBACK, &pFunc);
50+ encoder_->SetOption (ENCODER_OPTION_TRACE_CALLBACK_CONTEXT, &pTraceInfo);
51+ decoder_->SetOption (DECODER_OPTION_TRACE_CALLBACK, &pFunc);
52+ decoder_->SetOption (DECODER_OPTION_TRACE_CALLBACK_CONTEXT, &pTraceInfo);
3453 }
3554
3655 virtual void TearDown() {
@@ -67,6 +86,9 @@ class EncodeDecodeTestBase : public ::testing::TestWithParam<EncodeDecodeFilePar · 30 unmodified lines
6786 BufferedData buf_;
6887 SBufferInfo dstBufInfo_;
6988 std::vector<SLostSim> m_SLostSim;
89+ WelsTraceCallback pFunc;
90+ STraceUnit sTrace;
91+ STraceUnit* pTraceInfo;
7092 };
7193
7294 class EncodeDecodeTestAPI : public EncodeDecodeTestBase {
@@ -87,6 +109,7 @@ class EncodeDecodeTestAPI : public EncodeDecodeTestBase { · 14 unmodified lines
87109 static const EncodeDecodeFileParamBase kFileParamArray[] = {
88110 {300, 160, 96, 6.0f, 2, 1, "000000000000001010101010101010101010101001101010100000010101000011"},
89111 {300, 140, 96, 6.0f, 4, 1, "000000000000001010101010101010101010101001101010100000010101000011"},
112+ {300, 140, 96, 6.0f, 4, 1, "000000000000001010111010101011101010101001101010100000010101110011010101"},
90113 };
91114
92115 TEST_P (EncodeDecodeTestAPI, DecoderVclNal) {
@@ -330,6 +353,52 @@ void LTRMarkFeedback (ISVCDecoder* pDecoder, ISVCEncoder* pEncoder, SLTRMarkingF · 237 unmodified lines
330353 }
331354 }
332355
356+bool ToRemainDidNal (const unsigned char* pSrc, EWelsNalUnitType eNalType, int iTarDid) {
357+ uint8_t uiCurByte = *pSrc;
358+ if (IS_NEW_INTRODUCED_SVC_NAL (eNalType)) {
359+ int iDid = (uiCurByte & 0x70) >> 4;
360+ return iDid == iTarDid;
361+ } else if ((IS_VCL_NAL_AVC_BASE (eNalType)) && iTarDid != 0) {
362+ return false;
363+ } else {
364+ return true;
365+ }
366+}
367+
368+void ExtractDidNal (SFrameBSInfo* pBsInfo, int& iSrcLen, std::vector<SLostSim>* p_SLostSim, int iTarDid) {
369+ unsigned char* pDst = new unsigned char[iSrcLen];
370+ const unsigned char* pSrc = pBsInfo->sLayerInfo[0].pBsBuf;
371+ int iDstLen = 0;
372+ bool bLost;
373+ SLostSim tmpSLostSim;
374+ p_SLostSim->clear();
375+ int iPrefix;
376+ unsigned char* pSrcPtr = pBsInfo->sLayerInfo[0].pBsBuf;
377+ for (int j = 0; j < pBsInfo->iLayerNum; j++) {
378+ for (int k = 0; k < pBsInfo->sLayerInfo[j].iNalCount; k++) {
379+ if (pSrcPtr[0] == 0 && pSrcPtr[1] == 0 && pSrcPtr[2] == 0 && pSrcPtr[3] == 1) {
380+ iPrefix = 4;
381+ } else if (pSrcPtr[0] == 0 && pSrcPtr[1] == 0 && pSrcPtr[2] == 1) {
382+ iPrefix = 3;
383+ } else {
384+ iPrefix = 0;
385+ }
386+ tmpSLostSim.eNalType = (EWelsNalUnitType) ((* (pSrcPtr + iPrefix)) & 0x1f); // eNalUnitType
387+ bLost = (ToRemainDidNal ((pSrcPtr + iPrefix + 2), tmpSLostSim.eNalType, iTarDid)) ? false : true;
388+ tmpSLostSim.isLost = bLost;
389+ p_SLostSim->push_back (tmpSLostSim);
390+ if (!bLost) {
391+ memcpy (pDst + iDstLen, pSrcPtr, pBsInfo->sLayerInfo[j].pNalLengthInByte[k]);
392+ iDstLen += (pBsInfo->sLayerInfo[j].pNalLengthInByte[k]);
393+ }
394+ pSrcPtr += pBsInfo->sLayerInfo[j].pNalLengthInByte[k];
395+ }
396+ }
397+ memset ((void*)pSrc, 0, iSrcLen);
398+ memcpy ((void*)pSrc, pDst, iDstLen);
399+ iSrcLen = iDstLen;
400+ delete [] pDst;
401+}
333402
334403 int SimulateNALLoss (const unsigned char* pSrc, int& iSrcLen, std::vector<SLostSim>* p_SLostSim,
335404 const char* pLossChars, bool bLossPara, int& iLossIdx, bool& bVCLLoss) {
@@ -737,5 +806,405 @@ TEST_P (EncodeDecodeTestAPI, SetOptionECFlag_ERROR_CON_SLICE_COPY) { · 401 unmodified lines
737806 (void) iSkipedBytes;
738807 }
739808
809+TEST_P (EncodeDecodeTestAPI, GetOptionTid_AVC_NOPREFIX) {
810+ SLTRMarkingFeedback m_LTR_Marking_Feedback;
811+ SLTRRecoverRequest m_LTR_Recover_Request;
812+ m_LTR_Recover_Request.uiIDRPicId = 0;
813+ EncodeDecodeFileParamBase p = GetParam();
814+ prepareParam (p.width, p.height, p.frameRate);
815+ param_.bPrefixNalAddingCtrl = false;
816+ param_.iTemporalLayerNum = (rand() % 4) + 1;
817+ param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
818+ param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
819+ encoder_->Uninitialize();
820+ int rv = encoder_->InitializeExt (&param_);
821+ ASSERT_TRUE (rv == cmResultSuccess);
822+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
823+ int frameSize = p.width * p.height * 3 / 2;
824+ buf_.SetLength (frameSize);
825+ ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
826+ SFrameBSInfo info;
827+ memset (&info, 0, sizeof (SFrameBSInfo));
828+
829+ SSourcePicture pic;
830+ memset (&pic, 0, sizeof (SSourcePicture));
831+ pic.iPicWidth = p.width;
832+ pic.iPicHeight = p.height;
833+ pic.iColorFormat = videoFormatI420;
834+ pic.iStride[0] = pic.iPicWidth;
835+ pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
836+ pic.pData[0] = buf_.data();
837+ pic.pData[1] = pic.pData[0] + p.width * p.height;
838+ pic.pData[2] = pic.pData[1] + (p.width * p.height >> 2);
839+ int32_t iTraceLevel = WELS_LOG_QUIET;
840+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
841+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
842+ int32_t iSpsPpsIdAddition = 1;
843+ encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
844+ int32_t iIDRPeriod = 60;
845+ encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
846+ SLTRConfig sLtrConfigVal;
847+ sLtrConfigVal.bEnableLongTermReference = 1;
848+ sLtrConfigVal.iLTRRefNum = 1;
849+ encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
850+ int32_t iLtrPeriod = 2;
851+ encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
852+ int iIdx = 0;
853+ int iLossIdx = 0;
854+ bool bVCLLoss = false;
855+ while (iIdx <= p.numframes) {
856+ memset (buf_.data(), rand() % 256, frameSize);
857+ rv = encoder_->EncodeFrame (&pic, &info);
858+ if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) {
859+ ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
860+ }
861+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
862+ //decoding after each encoding frame
863+ int len = 0;
864+ encToDecData (info, len);
865+ unsigned char* pData[3] = { NULL };
866+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
867+ SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss);
868+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
869+ int iTid = -1;
870+ decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
871+ if (iTid != -1) {
872+ ASSERT_EQ (iTid, 0);
873+ }
874+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
875+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
876+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
877+ decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
878+ std::vector<SLostSim>::iterator iter = m_SLostSim.begin();
879+ bool bHasVCL = false;
880+ for (int k = 0; k < m_SLostSim.size(); k++) {
881+ if (IS_VCL_NAL (iter->eNalType, 0) && iter->isLost == false) {
882+ bHasVCL = true;
883+ break;
884+ }
885+ iter++;
886+ }
887+ if (iTid != -1) {
888+ ASSERT_EQ (iTid, 0);
889+ }
890+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
891+ LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
892+ iIdx++;
893+ }
894+}
895+
896+TEST_P (EncodeDecodeTestAPI, GetOptionTid_AVC_WITH_PREFIX_NOLOSS) {
897+ SLTRMarkingFeedback m_LTR_Marking_Feedback;
898+ SLTRRecoverRequest m_LTR_Recover_Request;
899+ m_LTR_Recover_Request.uiIDRPicId = 0;
900+ EncodeDecodeFileParamBase p = GetParam();
901+ prepareParam (p.width, p.height, p.frameRate);
902+ param_.bPrefixNalAddingCtrl = true;
903+ param_.iTemporalLayerNum = (rand() % 4) + 1;
904+ param_.iSpatialLayerNum = 1;
905+ param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
906+ param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
907+ encoder_->Uninitialize();
908+ int rv = encoder_->InitializeExt (&param_);
909+ ASSERT_TRUE (rv == cmResultSuccess);
910+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
911+ int frameSize = p.width * p.height * 3 / 2;
912+ buf_.SetLength (frameSize);
913+ ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
914+ SFrameBSInfo info;
915+ memset (&info, 0, sizeof (SFrameBSInfo));
916+
917+ SSourcePicture pic;
918+ memset (&pic, 0, sizeof (SSourcePicture));
919+ pic.iPicWidth = p.width;
920+ pic.iPicHeight = p.height;
921+ pic.iColorFormat = videoFormatI420;
922+ pic.iStride[0] = pic.iPicWidth;
923+ pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
924+ pic.pData[0] = buf_.data();
925+ pic.pData[1] = pic.pData[0] + p.width * p.height;
926+ pic.pData[2] = pic.pData[1] + (p.width * p.height >> 2);
927+ int32_t iTraceLevel = WELS_LOG_QUIET;
928+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
929+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
930+ int32_t iSpsPpsIdAddition = 1;
931+ encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
932+ int32_t iIDRPeriod = 60;
933+ encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
934+ SLTRConfig sLtrConfigVal;
935+ sLtrConfigVal.bEnableLongTermReference = 1;
936+ sLtrConfigVal.iLTRRefNum = 1;
937+ encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
938+ int32_t iLtrPeriod = 2;
939+ encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
940+ int iIdx = 0;
941+ while (iIdx <= p.numframes) {
942+ memset (buf_.data(), rand() % 256, frameSize);
943+ rv = encoder_->EncodeFrame (&pic, &info);
944+ if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) {
945+ ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
946+ }
947+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
948+ //decoding after each encoding frame
949+ int len = 0;
950+ encToDecData (info, len);
951+ unsigned char* pData[3] = { NULL };
952+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
953+ ExtractDidNal (&info, len, &m_SLostSim, 0);
954+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
955+ int iTid = -1;
956+ decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
957+ ASSERT_EQ (iTid, -1);
958+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
959+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
960+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
961+ decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
962+ ASSERT_EQ (iTid, info.sLayerInfo[0].uiTemporalId);
963+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
964+ LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
965+ iIdx++;
966+ }
967+}
968+
969+TEST_P (EncodeDecodeTestAPI, GetOptionTid_SVC_L1_NOLOSS) {
970+ SLTRMarkingFeedback m_LTR_Marking_Feedback;
971+ SLTRRecoverRequest m_LTR_Recover_Request;
972+ m_LTR_Recover_Request.uiIDRPicId = 0;
973+ EncodeDecodeFileParamBase p = GetParam();
974+ prepareParam (p.width / 2, p.height / 2, p.frameRate);
975+ param_.iTemporalLayerNum = (rand() % 4) + 1;
976+ param_.iSpatialLayerNum = 2;
977+ param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
978+ param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
979+ param_.sSpatialLayers[1].iVideoWidth = p.width;
980+ param_.sSpatialLayers[1].iVideoHeight = p.height;
981+ param_.sSpatialLayers[1].fFrameRate = p.frameRate;
982+ param_.sSpatialLayers[1].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
983+ param_.sSpatialLayers[1].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
984+
985+ encoder_->Uninitialize();
986+ int rv = encoder_->InitializeExt (&param_);
987+ ASSERT_TRUE (rv == cmResultSuccess);
988+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
989+ int frameSize = p.width * p.height * 3 / 2;
990+ buf_.SetLength (frameSize);
991+ ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
992+ SFrameBSInfo info;
993+ memset (&info, 0, sizeof (SFrameBSInfo));
994+
995+ SSourcePicture pic;
996+ memset (&pic, 0, sizeof (SSourcePicture));
997+ pic.iPicWidth = p.width;
998+ pic.iPicHeight = p.height;
999+ pic.iColorFormat = videoFormatI420;
1000+ pic.iStride[0] = pic.iPicWidth;
1001+ pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
1002+ pic.pData[0] = buf_.data();
1003+ pic.pData[1] = pic.pData[0] + p.width * p.height;
1004+ pic.pData[2] = pic.pData[1] + (p.width * p.height >> 2);
1005+ int32_t iTraceLevel = WELS_LOG_QUIET;
1006+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1007+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1008+ int32_t iSpsPpsIdAddition = 1;
1009+ encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
1010+ int32_t iIDRPeriod = 60;
1011+ encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
1012+ SLTRConfig sLtrConfigVal;
1013+ sLtrConfigVal.bEnableLongTermReference = 1;
1014+ sLtrConfigVal.iLTRRefNum = 1;
1015+ encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
1016+ int32_t iLtrPeriod = 2;
1017+ encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
1018+ int iIdx = 0;
1019+ while (iIdx <= p.numframes) {
1020+ memset (buf_.data(), rand() % 256, frameSize);
1021+ rv = encoder_->EncodeFrame (&pic, &info);
1022+ if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) {
1023+ ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
1024+ }
1025+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1026+ //decoding after each encoding frame
1027+ int len = 0;
1028+ encToDecData (info, len);
1029+ unsigned char* pData[3] = { NULL };
1030+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1031+ ExtractDidNal (&info, len, &m_SLostSim, 1);
1032+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1033+ int iTid = -1;
1034+ decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
1035+ ASSERT_EQ (iTid, -1);
1036+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
1037+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
1038+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1039+ decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
1040+ ASSERT_EQ (iTid, info.sLayerInfo[0].uiTemporalId);
1041+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
1042+ LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
1043+ iIdx++;
1044+ }
1045+}
1046+
1047+
1048+
1049+TEST_P (EncodeDecodeTestAPI, SetOption_Trace) {
1050+ SLTRMarkingFeedback m_LTR_Marking_Feedback;
1051+ SLTRRecoverRequest m_LTR_Recover_Request;
1052+ m_LTR_Recover_Request.uiIDRPicId = 0;
1053+ EncodeDecodeFileParamBase p = GetParam();
1054+ prepareParam (p.width, p.height, p.frameRate);
1055+ param_.iSpatialLayerNum = 1;
1056+ param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
1057+ param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
1058+
1059+ int rv = encoder_->InitializeExt (&param_);
1060+ ASSERT_TRUE (rv == cmResultSuccess);
1061+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
1062+ int frameSize = p.width * p.height * 3 / 2;
1063+ buf_.SetLength (frameSize);
1064+ ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
1065+ SFrameBSInfo info;
1066+ memset (&info, 0, sizeof (SFrameBSInfo));
1067+
1068+ SSourcePicture pic;
1069+ memset (&pic, 0, sizeof (SSourcePicture));
1070+ pic.iPicWidth = p.width;
1071+ pic.iPicHeight = p.height;
1072+ pic.iColorFormat = videoFormatI420;
1073+ pic.iStride[0] = pic.iPicWidth;
1074+ pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
1075+ pic.pData[0] = buf_.data();
1076+ pic.pData[1] = pic.pData[0] + p.width * p.height;
1077+ pic.pData[2] = pic.pData[1] + (p.width * p.height >> 2);
1078+ int32_t iTraceLevel = WELS_LOG_QUIET;
1079+ pFunc = TestOutPutTrace;
1080+ pTraceInfo = &sTrace;
1081+ sTrace.iTarLevel = iTraceLevel;
1082+ encoder_->SetOption (ENCODER_OPTION_TRACE_CALLBACK, &pFunc);
1083+ encoder_->SetOption (ENCODER_OPTION_TRACE_CALLBACK_CONTEXT, &pTraceInfo);
1084+ decoder_->SetOption (DECODER_OPTION_TRACE_CALLBACK, &pFunc);
1085+ decoder_->SetOption (DECODER_OPTION_TRACE_CALLBACK_CONTEXT, &pTraceInfo);
1086+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1087+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1088+
1089+ int32_t iSpsPpsIdAddition = 1;
1090+ encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
1091+ int32_t iIDRPeriod = 60;
1092+ encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
1093+ SLTRConfig sLtrConfigVal;
1094+ sLtrConfigVal.bEnableLongTermReference = 1;
1095+ sLtrConfigVal.iLTRRefNum = 1;
1096+ encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
1097+ int32_t iLtrPeriod = 2;
1098+ encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
1099+ int iIdx = 0;
1100+ int iLossIdx = 0;
1101+ bool bVCLLoss = false;
1102+ while (iIdx <= p.numframes) {
1103+ memset (buf_.data(), rand() % 256, frameSize);
1104+ iTraceLevel = rand() % 33;
1105+ sTrace.iTarLevel = iTraceLevel;
1106+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1107+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1108+ rv = encoder_->EncodeFrame (&pic, &info);
1109+ if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) {
1110+ ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
1111+ }
1112+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1113+ //decoding after each encoding frame
1114+ int len = 0;
1115+ encToDecData (info, len);
1116+ unsigned char* pData[3] = { NULL };
1117+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1118+ ExtractDidNal (&info, len, &m_SLostSim, 0);
1119+ SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss);
1120+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1121+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
1122+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
1123+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1124+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
1125+ LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
1126+ iIdx++;
1127+ }
1128+}
1129+
1130+TEST_P (EncodeDecodeTestAPI, SetOption_Trace_NULL) {
1131+ SLTRMarkingFeedback m_LTR_Marking_Feedback;
1132+ SLTRRecoverRequest m_LTR_Recover_Request;
1133+ m_LTR_Recover_Request.uiIDRPicId = 0;
1134+ EncodeDecodeFileParamBase p = GetParam();
1135+ prepareParam (p.width, p.height, p.frameRate);
1136+ param_.iSpatialLayerNum = 1;
1137+ param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
1138+ param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
1139+
1140+ int rv = encoder_->InitializeExt (&param_);
1141+ ASSERT_TRUE (rv == cmResultSuccess);
1142+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
1143+ int frameSize = p.width * p.height * 3 / 2;
1144+ buf_.SetLength (frameSize);
1145+ ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
1146+ SFrameBSInfo info;
1147+ memset (&info, 0, sizeof (SFrameBSInfo));
1148+
1149+ SSourcePicture pic;
1150+ memset (&pic, 0, sizeof (SSourcePicture));
1151+ pic.iPicWidth = p.width;
1152+ pic.iPicHeight = p.height;
1153+ pic.iColorFormat = videoFormatI420;
1154+ pic.iStride[0] = pic.iPicWidth;
1155+ pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
1156+ pic.pData[0] = buf_.data();
1157+ pic.pData[1] = pic.pData[0] + p.width * p.height;
1158+ pic.pData[2] = pic.pData[1] + (p.width * p.height >> 2);
1159+ int32_t iTraceLevel = WELS_LOG_QUIET;
1160+ pFunc = NULL;
1161+ pTraceInfo = NULL;
1162+ encoder_->SetOption (ENCODER_OPTION_TRACE_CALLBACK, &pFunc);
1163+ encoder_->SetOption (ENCODER_OPTION_TRACE_CALLBACK_CONTEXT, &pTraceInfo);
1164+ decoder_->SetOption (DECODER_OPTION_TRACE_CALLBACK, &pFunc);
1165+ decoder_->SetOption (DECODER_OPTION_TRACE_CALLBACK_CONTEXT, &pTraceInfo);
1166+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1167+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1168+
1169+ int32_t iSpsPpsIdAddition = 1;
1170+ encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
1171+ int32_t iIDRPeriod = 60;
1172+ encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
1173+ SLTRConfig sLtrConfigVal;
1174+ sLtrConfigVal.bEnableLongTermReference = 1;
1175+ sLtrConfigVal.iLTRRefNum = 1;
1176+ encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
1177+ int32_t iLtrPeriod = 2;
1178+ encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
1179+ int iIdx = 0;
1180+ int iLossIdx = 0;
1181+ bool bVCLLoss = false;
1182+ while (iIdx <= p.numframes) {
1183+ memset (buf_.data(), rand() % 256, frameSize);
1184+ iTraceLevel = rand() % 33;
1185+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1186+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1187+ rv = encoder_->EncodeFrame (&pic, &info);
1188+ if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) {
1189+ ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
1190+ }
1191+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1192+ //decoding after each encoding frame
1193+ int len = 0;
1194+ encToDecData (info, len);
1195+ unsigned char* pData[3] = { NULL };
1196+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1197+ ExtractDidNal (&info, len, &m_SLostSim, 0);
1198+ SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss);
1199+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1200+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
1201+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
1202+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1203+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
1204+ LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
1205+ iIdx++;
1206+ }
1207+}
1208+
7401209 INSTANTIATE_TEST_CASE_P (EncodeDecodeTestBase, EncodeDecodeTestAPI,
7411210 ::testing::ValuesIn (kFileParamArray));

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t