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
25 const char* pLossSequence;25 const char* pLossSequence;
26};26};
27 27
28static void welsStderrTraceOrigin (void* ctx, int level, const char* string) {
29 fprintf (stderr, "%s\n", string);
30}
31
32typedef struct STrace_Unit {
33 int iTarLevel;
34} STraceUnit;
35
36static void TestOutPutTrace (void* ctx, int level, const char* string) {
37 STraceUnit* pTraceUnit = (STraceUnit*) ctx;
38 EXPECT_LE (level, pTraceUnit->iTarLevel);
39}
40
28class EncodeDecodeTestBase : public ::testing::TestWithParam<EncodeDecodeFileParamBase>,41class EncodeDecodeTestBase : public ::testing::TestWithParam<EncodeDecodeFileParamBase>,
29 public BaseEncoderTest, public BaseDecoderTest {42 public BaseEncoderTest, public BaseDecoderTest {
30 public:43 public:
31 virtual void SetUp() {44 virtual void SetUp() {
32 BaseEncoderTest::SetUp();45 BaseEncoderTest::SetUp();
33 BaseDecoderTest::SetUp();46 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);
34 }53 }
35 54
36 virtual void TearDown() {55 virtual void TearDown() {
@@ -67,6 +86,9 @@ class EncodeDecodeTestBase : public ::testing::TestWithParam<EncodeDecodeFilePar · 30 unmodified lines
67 BufferedData buf_;86 BufferedData buf_;
68 SBufferInfo dstBufInfo_;87 SBufferInfo dstBufInfo_;
69 std::vector<SLostSim> m_SLostSim;88 std::vector<SLostSim> m_SLostSim;
89 WelsTraceCallback pFunc;
90 STraceUnit sTrace;
91 STraceUnit* pTraceInfo;
70};92};
71 93
72class EncodeDecodeTestAPI : public EncodeDecodeTestBase {94class EncodeDecodeTestAPI : public EncodeDecodeTestBase {
@@ -87,6 +109,7 @@ class EncodeDecodeTestAPI : public EncodeDecodeTestBase { · 14 unmodified lines
87static const EncodeDecodeFileParamBase kFileParamArray[] = {109static const EncodeDecodeFileParamBase kFileParamArray[] = {
88 {300, 160, 96, 6.0f, 2, 1, "000000000000001010101010101010101010101001101010100000010101000011"},110 {300, 160, 96, 6.0f, 2, 1, "000000000000001010101010101010101010101001101010100000010101000011"},
89 {300, 140, 96, 6.0f, 4, 1, "000000000000001010101010101010101010101001101010100000010101000011"},111 {300, 140, 96, 6.0f, 4, 1, "000000000000001010101010101010101010101001101010100000010101000011"},
112 {300, 140, 96, 6.0f, 4, 1, "000000000000001010111010101011101010101001101010100000010101110011010101"},
90};113};
91 114
92TEST_P (EncodeDecodeTestAPI, DecoderVclNal) {115TEST_P (EncodeDecodeTestAPI, DecoderVclNal) {
@@ -330,6 +353,52 @@ void LTRMarkFeedback (ISVCDecoder* pDecoder, ISVCEncoder* pEncoder, SLTRMarkingF · 237 unmodified lines
330 }353 }
331}354}
332 355
356bool 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
368void 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}
333 402
334int SimulateNALLoss (const unsigned char* pSrc, int& iSrcLen, std::vector<SLostSim>* p_SLostSim,403int SimulateNALLoss (const unsigned char* pSrc, int& iSrcLen, std::vector<SLostSim>* p_SLostSim,
335 const char* pLossChars, bool bLossPara, int& iLossIdx, bool& bVCLLoss) {404 const char* pLossChars, bool bLossPara, int& iLossIdx, bool& bVCLLoss) {
@@ -737,5 +806,405 @@ TEST_P (EncodeDecodeTestAPI, SetOptionECFlag_ERROR_CON_SLICE_COPY) { · 401 unmodified lines
737 (void) iSkipedBytes;806 (void) iSkipedBytes;
738}807}
739 808
809TEST_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
896TEST_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
969TEST_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
1049TEST_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
1130TEST_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
740INSTANTIATE_TEST_CASE_P (EncodeDecodeTestBase, EncodeDecodeTestAPI,1209INSTANTIATE_TEST_CASE_P (EncodeDecodeTestBase, EncodeDecodeTestAPI,
741 ::testing::ValuesIn (kFileParamArray));1210 ::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