1. add encoder-engine-decoder API UT for: IDR request, LTR request 2. add decoder api UT for EC: Disable/Enable EC 3. Fix a decoder bug when EC is disabled itoltalMbDec should be set to zero when encouter a new sequence/picture, even when EC is disabled.

dongzha committed 12 years ago

Commit 311f7001 parent 679cc4a4 files · +527 −26Browse files

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

Unified · Split

test/api/encode_decode_api_test.cpp+511−12

@@ -4,16 +4,28 @@ · 3 unmodified lines
4	4	#include "utils/FileInputStream.h"
5	5	#include "BaseDecoderTest.h"
6	6	#include "BaseEncoderTest.h"
	7	+#include "wels_common_defs.h"
7	8	#include <string>
	9	+#include <vector>
	10	+using namespace WelsCommon;
	11	+
	12	+typedef struct SLost_Sim {
	13	+ WelsCommon::EWelsNalUnitType eNalType;
	14	+ bool isLost;
	15	+} SLostSim;
	16	+
8	17
9	18	struct EncodeDecodeFileParamBase {
10	19	int numframes;
11	20	int width;
12	21	int height;
13	22	float frameRate;
	23	+ int slicenum;
	24	+ bool bLostPara;
	25	+ const char* pLossSequence;
14	26	};
15	27
16		−class EncodeDecodeTestBase : public ::testing::Test,
	28	+class EncodeDecodeTestBase : public ::testing::TestWithParam<EncodeDecodeFileParamBase>,
17	29	public BaseEncoderTest, public BaseDecoderTest {
18	30	public:
19	31	virtual void SetUp() {
@@ -54,6 +66,7 @@ class EncodeDecodeTestBase : public ::testing::Test, · 34 unmodified lines
54	66	SEncParamExt param_;
55	67	BufferedData buf_;
56	68	SBufferInfo dstBufInfo_;
	69	+ std::vector<SLostSim> m_SLostSim;
57	70	};
58	71
59	72	class EncodeDecodeTestAPI : public EncodeDecodeTestBase {
@@ -71,12 +84,15 @@ class EncodeDecodeTestAPI : public EncodeDecodeTestBase { · 11 unmodified lines
71	84	}
72	85	};
73	86
74		−static const EncodeDecodeFileParamBase kFileParamArray =
75		−{300, 160, 96, 6.0f};
	87	+static const EncodeDecodeFileParamBase kFileParamArray[] = {
	88	+ {300, 160, 96, 6.0f, 2, 1, "000000000000001010101010101010101010101001101010100000010101000011"},
	89	+ {300, 140, 96, 6.0f, 4, 1, "000000000000001010101010101010101010101001101010100000010101000011"},
	90	+};
76	91
77		−TEST_F (EncodeDecodeTestAPI, DecoderVclNal) {
78		− EncodeDecodeFileParamBase p = kFileParamArray;
	92	+TEST_P (EncodeDecodeTestAPI, DecoderVclNal) {
	93	+ EncodeDecodeFileParamBase p = GetParam();
79	94	prepareParam (p.width, p.height, p.frameRate);
	95	+ encoder_->Uninitialize();
80	96	int rv = encoder_->InitializeExt (&param_);
81	97	ASSERT_TRUE (rv == cmResultSuccess);
82	98
@@ -86,7 +102,9 @@ TEST_F (EncodeDecodeTestAPI, DecoderVclNal) { · 3 unmodified lines
86	102
87	103	buf_.SetLength (frameSize);
88	104	ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
89		−
	105	+ int32_t iTraceLevel = WELS_LOG_QUIET;
	106	+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
	107	+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
90	108	SFrameBSInfo info;
91	109	memset (&info, 0, sizeof (SFrameBSInfo));
92	110
@@ -123,16 +141,19 @@ TEST_F (EncodeDecodeTestAPI, DecoderVclNal) { · 30 unmodified lines
123	141	//ignore last frame
124	142	}
125	143
126		−TEST_F (EncodeDecodeTestAPI, GetOptionFramenum) {
127		− EncodeDecodeFileParamBase p = kFileParamArray;
	144	+TEST_P (EncodeDecodeTestAPI, GetOptionFramenum) {
	145	+ EncodeDecodeFileParamBase p = GetParam();
128	146	prepareParam (p.width, p.height, p.frameRate);
	147	+ encoder_->Uninitialize();
129	148	int rv = encoder_->InitializeExt (&param_);
130	149	ASSERT_TRUE (rv == cmResultSuccess);
131	150
132	151	//init for encoder
133	152	// I420: 1(Y) + 1/4(U) + 1/4(V)
134	153	int frameSize = p.width * p.height * 3 / 2;
135		−
	154	+ int32_t iTraceLevel = WELS_LOG_QUIET;
	155	+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
	156	+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
136	157	buf_.SetLength (frameSize);
137	158	ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
138	159
@@ -175,16 +196,19 @@ TEST_F (EncodeDecodeTestAPI, GetOptionFramenum) { · 36 unmodified lines
175	196	//ignore last frame
176	197	}
177	198
178		−TEST_F (EncodeDecodeTestAPI, GetOptionIDR) {
179		− EncodeDecodeFileParamBase p = kFileParamArray;
	199	+TEST_P (EncodeDecodeTestAPI, GetOptionIDR) {
	200	+ EncodeDecodeFileParamBase p = GetParam();
180	201	prepareParam (p.width, p.height, p.frameRate);
	202	+ encoder_->Uninitialize();
181	203	int rv = encoder_->InitializeExt (&param_);
182	204	ASSERT_TRUE (rv == cmResultSuccess);
183	205
184	206	//init for encoder
185	207	// I420: 1(Y) + 1/4(U) + 1/4(V)
186	208	int frameSize = p.width * p.height * 3 / 2;
187		−
	209	+ int32_t iTraceLevel = WELS_LOG_QUIET;
	210	+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
	211	+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
188	212	buf_.SetLength (frameSize);
189	213	ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
190	214
@@ -236,3 +260,478 @@ TEST_F (EncodeDecodeTestAPI, GetOptionIDR) { · 45 unmodified lines
236	260	}
237	261
238	262
	263	+long IsKeyFrameLost (ISVCDecoder* pDecoder, SLTRRecoverRequest* p_LTR_Recover_Request, long hr) {
	264	+ long bLost = NO_RECOVERY_REQUSET;
	265	+ int tempInt = -1;
	266	+ int temple_id = -1;
	267	+ bool m_P2PmodeFlag = true;
	268	+ pDecoder->GetOption (DECODER_OPTION_TEMPORAL_ID, &temple_id);
	269	+ if (hr == dsErrorFree) {
	270	+ if (m_P2PmodeFlag && temple_id == 0) {
	271	+ pDecoder->GetOption (DECODER_OPTION_IDR_PIC_ID, &tempInt);
	272	+ // idr_pic_id change ,reset last correct position
	273	+ if (p_LTR_Recover_Request->uiIDRPicId != tempInt) {
	274	+ p_LTR_Recover_Request->uiIDRPicId = tempInt;
	275	+ p_LTR_Recover_Request->iLastCorrectFrameNum = -1;
	276	+ }
	277	+ pDecoder->GetOption (DECODER_OPTION_FRAME_NUM, &tempInt);
	278	+ if (tempInt >= 0) {
	279	+ p_LTR_Recover_Request->iLastCorrectFrameNum = tempInt;
	280	+ }
	281	+ }
	282	+ bLost = NO_RECOVERY_REQUSET;
	283	+ } else if (hr & dsNoParamSets) {
	284	+ bLost = IDR_RECOVERY_REQUEST;
	285	+ } else if (((hr & dsRefLost) && (1 == temple_id)) \|\| ((dsErrorFree != hr) && (0 == temple_id))) {
	286	+ bLost = LTR_RECOVERY_REQUEST;
	287	+ } else {
	288	+ bLost = NO_RECOVERY_REQUSET;
	289	+ }
	290	+ return bLost;
	291	+}
	292	+
	293	+bool IsLTRMarking (ISVCDecoder* pDecoder) {
	294	+ int bLTR_marking_flag = 0;
	295	+ pDecoder->GetOption (DECODER_OPTION_LTR_MARKING_FLAG, &bLTR_marking_flag);
	296	+ return (bLTR_marking_flag) ? (true) : (false);
	297	+}
	298	+
	299	+void LTRRecoveryRequest (ISVCDecoder* pDecoder, ISVCEncoder* pEncoder, SLTRRecoverRequest* p_LTR_Recover_Request,
	300	+ long hr) {
	301	+
	302	+ long bKLost = IsKeyFrameLost (pDecoder, p_LTR_Recover_Request, hr);
	303	+ bool m_P2PmodeFlag = true;
	304	+ if (m_P2PmodeFlag) {
	305	+ if (bKLost == IDR_RECOVERY_REQUEST) {
	306	+ pEncoder->ForceIntraFrame (true);
	307	+ } else if (bKLost == LTR_RECOVERY_REQUEST) {
	308	+ p_LTR_Recover_Request->uiFeedbackType = LTR_RECOVERY_REQUEST;
	309	+ pDecoder->GetOption (DECODER_OPTION_FRAME_NUM, &p_LTR_Recover_Request->iCurrentFrameNum);
	310	+ pDecoder->GetOption (DECODER_OPTION_IDR_PIC_ID, &p_LTR_Recover_Request->uiIDRPicId);
	311	+ pEncoder->SetOption (ENCODER_LTR_RECOVERY_REQUEST, p_LTR_Recover_Request);
	312	+ }
	313	+ } else {
	314	+ if (bKLost == IDR_RECOVERY_REQUEST \|\| bKLost == LTR_RECOVERY_REQUEST) {
	315	+ p_LTR_Recover_Request->uiFeedbackType = IDR_RECOVERY_REQUEST;
	316	+ pDecoder->GetOption (DECODER_OPTION_FRAME_NUM, &p_LTR_Recover_Request->iCurrentFrameNum);
	317	+ pDecoder->GetOption (DECODER_OPTION_IDR_PIC_ID, &p_LTR_Recover_Request->uiIDRPicId);
	318	+ pEncoder->SetOption (ENCODER_LTR_RECOVERY_REQUEST, p_LTR_Recover_Request);
	319	+ }
	320	+ }
	321	+}
	322	+
	323	+void LTRMarkFeedback (ISVCDecoder* pDecoder, ISVCEncoder* pEncoder, SLTRMarkingFeedback* p_LTR_Marking_Feedback,
	324	+ long hr) {
	325	+ if (IsLTRMarking (pDecoder) == true) {
	326	+ p_LTR_Marking_Feedback->uiFeedbackType = (hr == dsErrorFree) ? (LTR_MARKING_SUCCESS) : (LTR_MARKING_FAILED);
	327	+ pDecoder->GetOption (DECODER_OPTION_IDR_PIC_ID, &p_LTR_Marking_Feedback->uiIDRPicId);
	328	+ pDecoder->GetOption (DECODER_OPTION_LTR_MARKED_FRAME_NUM, &p_LTR_Marking_Feedback->iLTRFrameNum);
	329	+ pEncoder->SetOption (ENCODER_LTR_MARKING_FEEDBACK, p_LTR_Marking_Feedback);
	330	+ }
	331	+}
	332	+
	333	+
	334	+int SimulateNALLoss (const unsigned char* pSrc, int& iSrcLen, std::vector<SLostSim>* p_SLostSim,
	335	+ const char* pLossChars, bool bLossPara, int& iLossIdx, bool& bVCLLoss) {
	336	+ unsigned char* pDst = new unsigned char[iSrcLen];
	337	+ int iLossCharLen = strlen (pLossChars);
	338	+ int iSkipedBytes = 0;
	339	+ int iDstLen = 0;
	340	+ int iBufPos = 0;
	341	+ int ilastprefixlen = 0;
	342	+ int i = 0;
	343	+ bool bLost;
	344	+ bVCLLoss = false;
	345	+ SLostSim tmpSLostSim;
	346	+ p_SLostSim->clear();
	347	+ for (i = 0; i < iSrcLen;) {
	348	+ if (pSrc[i] == 0 && pSrc[i + 1] == 0 && pSrc[i + 2] == 0 && pSrc[i + 3] == 1) {
	349	+ if (i - iBufPos) {
	350	+ tmpSLostSim.eNalType = (EWelsNalUnitType) ((* (pSrc + iBufPos + ilastprefixlen)) & 0x1f); // eNalUnitType
	351	+ bLost = iLossIdx < iLossCharLen ? (pLossChars[iLossIdx] == '1') : (rand() % 2 == 1);
	352	+ bLost = (!bLossPara) && (IS_PARAM_SETS_NALS (tmpSLostSim.eNalType)) ? false : bLost;
	353	+ iLossIdx++;
	354	+ tmpSLostSim.isLost = bLost;
	355	+ p_SLostSim->push_back (tmpSLostSim);
	356	+ if (!bLost) {
	357	+ memcpy (pDst + iDstLen, pSrc + iBufPos, i - iBufPos);
	358	+ iDstLen += (i - iBufPos);
	359	+ } else {
	360	+ bVCLLoss = (IS_VCL_NAL (tmpSLostSim.eNalType, 1)) ? true : bVCLLoss;
	361	+ iSkipedBytes += (i - iBufPos);
	362	+ }
	363	+ }
	364	+ ilastprefixlen = 4;
	365	+ iBufPos = i;
	366	+ i = i + 4;
	367	+ } else if (pSrc[i] == 0 && pSrc[i + 1] == 0 && pSrc[i + 2] == 1) {
	368	+ if (i - iBufPos) {
	369	+ tmpSLostSim.eNalType = (EWelsNalUnitType) ((* (pSrc + iBufPos + ilastprefixlen)) & 0x1f); // eNalUnitType
	370	+ bLost = iLossIdx < iLossCharLen ? (pLossChars[iLossIdx] == '1') : (rand() % 2 == 1);
	371	+ bLost = (!bLossPara) && (IS_PARAM_SETS_NALS (tmpSLostSim.eNalType)) ? false : bLost;
	372	+ iLossIdx++;
	373	+ tmpSLostSim.isLost = bLost;
	374	+ p_SLostSim->push_back (tmpSLostSim);
	375	+ if (!bLost) {
	376	+ memcpy (pDst + iDstLen, pSrc + iBufPos, i - iBufPos);
	377	+ iDstLen += (i - iBufPos);
	378	+ } else {
	379	+ bVCLLoss = (IS_VCL_NAL (tmpSLostSim.eNalType, 1)) ? true : bVCLLoss;
	380	+ iSkipedBytes += (i - iBufPos);
	381	+ }
	382	+ }
	383	+ ilastprefixlen = 3;
	384	+ iBufPos = i;
	385	+ i = i + 3;
	386	+ } else {
	387	+ i++;
	388	+ }
	389	+ }
	390	+ if (i - iBufPos) {
	391	+ tmpSLostSim.eNalType = (EWelsNalUnitType) ((* (pSrc + iBufPos + ilastprefixlen)) & 0x1f); // eNalUnitType
	392	+ bLost = iLossIdx < iLossCharLen ? (pLossChars[iLossIdx] == '1') : (rand() % 2 == 1);
	393	+ bLost = (!bLossPara) && (IS_PARAM_SETS_NALS (tmpSLostSim.eNalType)) ? false : bLost;
	394	+ iLossIdx++;
	395	+ tmpSLostSim.isLost = bLost;
	396	+ p_SLostSim->push_back (tmpSLostSim);
	397	+ if (!bLost) {
	398	+ memcpy (pDst + iDstLen, pSrc + iBufPos, i - iBufPos);
	399	+ iDstLen += (i - iBufPos);
	400	+ } else {
	401	+ bVCLLoss = (IS_VCL_NAL (tmpSLostSim.eNalType, 1)) ? true : bVCLLoss;
	402	+ iSkipedBytes += (i - iBufPos);
	403	+ }
	404	+ }
	405	+ memset ((void*)pSrc, 0, iSrcLen);
	406	+ memcpy ((void*)pSrc, pDst, iDstLen);
	407	+ iSrcLen = iDstLen;
	408	+ delete pDst;
	409	+ return iSkipedBytes;
	410	+}
	411	+
	412	+TEST_P (EncodeDecodeTestAPI, GetOptionLTR_ALLIDR) {
	413	+ EncodeDecodeFileParamBase p = GetParam();
	414	+ prepareParam (p.width, p.height, p.frameRate);
	415	+ encoder_->Uninitialize();
	416	+ int rv = encoder_->InitializeExt (&param_);
	417	+ ASSERT_TRUE (rv == cmResultSuccess);
	418	+ int frameSize = p.width * p.height * 3 / 2;
	419	+ buf_.SetLength (frameSize);
	420	+ ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
	421	+
	422	+ SFrameBSInfo info;
	423	+ memset (&info, 0, sizeof (SFrameBSInfo));
	424	+ SSourcePicture pic;
	425	+ memset (&pic, 0, sizeof (SSourcePicture));
	426	+ pic.iPicWidth = p.width;
	427	+ pic.iPicHeight = p.height;
	428	+ pic.iColorFormat = videoFormatI420;
	429	+ pic.iStride[0] = pic.iPicWidth;
	430	+ pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
	431	+ pic.pData[0] = buf_.data();
	432	+ pic.pData[1] = pic.pData[0] + p.width * p.height;
	433	+ pic.pData[2] = pic.pData[1] + (p.width * p.height >> 2);
	434	+ int32_t iTraceLevel = WELS_LOG_QUIET;
	435	+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
	436	+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
	437	+ int32_t iSpsPpsIdAddition = 1;
	438	+ encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
	439	+ int32_t iIDRPeriod = 60;
	440	+ encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
	441	+ SLTRConfig sLtrConfigVal;
	442	+ sLtrConfigVal.bEnableLongTermReference = 1;
	443	+ sLtrConfigVal.iLTRRefNum = 1;
	444	+ encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
	445	+ int32_t iLtrPeriod = 2;
	446	+ encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
	447	+ int iIdx = 0;
	448	+ while (iIdx <= p.numframes) {
	449	+ memset (buf_.data(), rand() % 256, frameSize);
	450	+ rv = encoder_->EncodeFrame (&pic, &info);
	451	+ ASSERT_EQ (rv, cmResultSuccess);
	452	+ ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
	453	+ encoder_->ForceIntraFrame (true);
	454	+ iIdx++;
	455	+ }
	456	+}
	457	+
	458	+TEST_P (EncodeDecodeTestAPI, GetOptionLTR_ALLLTR) {
	459	+ SLTRMarkingFeedback m_LTR_Marking_Feedback;
	460	+ SLTRRecoverRequest m_LTR_Recover_Request;
	461	+ EncodeDecodeFileParamBase p = GetParam();
	462	+ prepareParam (p.width, p.height, p.frameRate);
	463	+ encoder_->Uninitialize();
	464	+ int rv = encoder_->InitializeExt (&param_);
	465	+ ASSERT_TRUE (rv == cmResultSuccess);
	466	+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
	467	+ int frameSize = p.width * p.height * 3 / 2;
	468	+ buf_.SetLength (frameSize);
	469	+ ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
	470	+ SFrameBSInfo info;
	471	+ memset (&info, 0, sizeof (SFrameBSInfo));
	472	+
	473	+ SSourcePicture pic;
	474	+ memset (&pic, 0, sizeof (SSourcePicture));
	475	+ pic.iPicWidth = p.width;
	476	+ pic.iPicHeight = p.height;
	477	+ pic.iColorFormat = videoFormatI420;
	478	+ pic.iStride[0] = pic.iPicWidth;
	479	+ pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
	480	+ pic.pData[0] = buf_.data();
	481	+ pic.pData[1] = pic.pData[0] + p.width * p.height;
	482	+ pic.pData[2] = pic.pData[1] + (p.width * p.height >> 2);
	483	+ int32_t iTraceLevel = WELS_LOG_QUIET;
	484	+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
	485	+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
	486	+ int32_t iSpsPpsIdAddition = 1;
	487	+ encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
	488	+ int32_t iIDRPeriod = 60;
	489	+ encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
	490	+ SLTRConfig sLtrConfigVal;
	491	+ sLtrConfigVal.bEnableLongTermReference = 1;
	492	+ sLtrConfigVal.iLTRRefNum = 1;
	493	+ encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
	494	+ int32_t iLtrPeriod = 2;
	495	+ encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
	496	+ int iIdx = 0;
	497	+ while (iIdx <= p.numframes) {
	498	+ memset (buf_.data(), rand() % 256, frameSize);
	499	+ rv = encoder_->EncodeFrame (&pic, &info);
	500	+ if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) {
	501	+ ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
	502	+ }
	503	+ ASSERT_TRUE (rv == cmResultSuccess \|\| rv == cmUnkonwReason);
	504	+ m_LTR_Recover_Request.uiFeedbackType = LTR_RECOVERY_REQUEST;
	505	+ m_LTR_Recover_Request.iCurrentFrameNum = rand() % 2 == 1 ? -rand() % 10000 : rand() % 10000;
	506	+ m_LTR_Recover_Request.uiIDRPicId = rand() % 2 == 1 ? -rand() % 10000 : rand() % 10000;
	507	+ encoder_->SetOption (ENCODER_LTR_RECOVERY_REQUEST, &m_LTR_Recover_Request);
	508	+ m_LTR_Marking_Feedback.uiFeedbackType = rand() % 2 == 1 ? LTR_MARKING_SUCCESS : LTR_MARKING_FAILED;
	509	+ m_LTR_Marking_Feedback.uiIDRPicId = rand() % 2 == 1 ? -rand() % 10000 : rand() % 10000;
	510	+ m_LTR_Marking_Feedback.iLTRFrameNum = rand() % 2 == 1 ? -rand() % 10000 : rand() % 10000;
	511	+ encoder_->SetOption (ENCODER_LTR_MARKING_FEEDBACK, &m_LTR_Marking_Feedback);
	512	+ iIdx++;
	513	+ }
	514	+}
	515	+
	516	+TEST_P (EncodeDecodeTestAPI, GetOptionLTR_Engine) {
	517	+ SLTRMarkingFeedback m_LTR_Marking_Feedback;
	518	+ SLTRRecoverRequest m_LTR_Recover_Request;
	519	+ EncodeDecodeFileParamBase p = GetParam();
	520	+ prepareParam (p.width, p.height, p.frameRate);
	521	+ param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
	522	+ param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
	523	+ encoder_->Uninitialize();
	524	+ int rv = encoder_->InitializeExt (&param_);
	525	+ ASSERT_TRUE (rv == cmResultSuccess);
	526	+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
	527	+ int frameSize = p.width * p.height * 3 / 2;
	528	+ buf_.SetLength (frameSize);
	529	+ ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
	530	+ SFrameBSInfo info;
	531	+ memset (&info, 0, sizeof (SFrameBSInfo));
	532	+
	533	+ SSourcePicture pic;
	534	+ memset (&pic, 0, sizeof (SSourcePicture));
	535	+ pic.iPicWidth = p.width;
	536	+ pic.iPicHeight = p.height;
	537	+ pic.iColorFormat = videoFormatI420;
	538	+ pic.iStride[0] = pic.iPicWidth;
	539	+ pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
	540	+ pic.pData[0] = buf_.data();
	541	+ pic.pData[1] = pic.pData[0] + p.width * p.height;
	542	+ pic.pData[2] = pic.pData[1] + (p.width * p.height >> 2);
	543	+ int32_t iTraceLevel = WELS_LOG_QUIET;
	544	+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
	545	+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
	546	+ int32_t iSpsPpsIdAddition = 1;
	547	+ encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
	548	+ int32_t iIDRPeriod = 60;
	549	+ encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
	550	+ SLTRConfig sLtrConfigVal;
	551	+ sLtrConfigVal.bEnableLongTermReference = 1;
	552	+ sLtrConfigVal.iLTRRefNum = 1;
	553	+ encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
	554	+ int32_t iLtrPeriod = 2;
	555	+ encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
	556	+ int iIdx = 0;
	557	+ int iLossIdx = 0;
	558	+ bool bVCLLoss = false;
	559	+ while (iIdx <= p.numframes) {
	560	+ memset (buf_.data(), rand() % 256, frameSize);
	561	+ rv = encoder_->EncodeFrame (&pic, &info);
	562	+ if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) {
	563	+ ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
	564	+ }
	565	+ ASSERT_TRUE (rv == cmResultSuccess \|\| rv == cmUnkonwReason);
	566	+ //decoding after each encoding frame
	567	+ int len = 0;
	568	+ encToDecData (info, len);
	569	+ unsigned char* pData[3] = { NULL };
	570	+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
	571	+ SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss);
	572	+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
	573	+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
	574	+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
	575	+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
	576	+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
	577	+ LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
	578	+ iIdx++;
	579	+ }
	580	+}
	581	+
	582	+TEST_P (EncodeDecodeTestAPI, SetOptionECFlag_ERROR_CON_DISABLE) {
	583	+ SLTRMarkingFeedback m_LTR_Marking_Feedback;
	584	+ SLTRRecoverRequest m_LTR_Recover_Request;
	585	+ EncodeDecodeFileParamBase p = GetParam();
	586	+ prepareParam (p.width, p.height, p.frameRate);
	587	+ param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
	588	+ param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
	589	+ param_.bEnableLongTermReference = true;
	590	+ param_.iLTRRefNum = 1;
	591	+ encoder_->Uninitialize();
	592	+ int rv = encoder_->InitializeExt (&param_);
	593	+ ASSERT_TRUE (rv == cmResultSuccess);
	594	+ if (decoder_ != NULL) {
	595	+ decoder_->Uninitialize();
	596	+ }
	597	+ SDecodingParam decParam;
	598	+ memset (&decParam, 0, sizeof (SDecodingParam));
	599	+ decParam.eOutputColorFormat = videoFormatI420;
	600	+ decParam.uiTargetDqLayer = UCHAR_MAX;
	601	+ decParam.eEcActiveIdc = ERROR_CON_DISABLE;
	602	+ decParam.sVideoProperty.eVideoBsType = VIDEO_BITSTREAM_DEFAULT;
	603	+ rv = decoder_->Initialize (&decParam);
	604	+ ASSERT_EQ (0, rv);
	605	+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
	606	+ int frameSize = p.width * p.height * 3 / 2;
	607	+ buf_.SetLength (frameSize);
	608	+ ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
	609	+ SFrameBSInfo info;
	610	+ memset (&info, 0, sizeof (SFrameBSInfo));
	611	+
	612	+ SSourcePicture pic;
	613	+ memset (&pic, 0, sizeof (SSourcePicture));
	614	+ pic.iPicWidth = p.width;
	615	+ pic.iPicHeight = p.height;
	616	+ pic.iColorFormat = videoFormatI420;
	617	+ pic.iStride[0] = pic.iPicWidth;
	618	+ pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
	619	+ pic.pData[0] = buf_.data();
	620	+ pic.pData[1] = pic.pData[0] + p.width * p.height;
	621	+ pic.pData[2] = pic.pData[1] + (p.width * p.height >> 2);
	622	+ int32_t iTraceLevel = WELS_LOG_QUIET;
	623	+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
	624	+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
	625	+ int32_t iSpsPpsIdAddition = 1;
	626	+ encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
	627	+ int32_t iIDRPeriod = 60;
	628	+ encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
	629	+ SLTRConfig sLtrConfigVal;
	630	+ sLtrConfigVal.bEnableLongTermReference = 1;
	631	+ sLtrConfigVal.iLTRRefNum = 1;
	632	+ encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
	633	+ int32_t iLtrPeriod = 2;
	634	+ encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
	635	+ int iIdx = 0;
	636	+ int iLossIdx = 0;
	637	+ int iSkipedBytes;
	638	+ bool bVCLLoss = false;
	639	+ while (iIdx <= p.numframes) {
	640	+ memset (buf_.data(), rand() % 256, frameSize);
	641	+ rv = encoder_->EncodeFrame (&pic, &info);
	642	+ if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) {
	643	+ ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
	644	+ }
	645	+ ASSERT_TRUE (rv == cmResultSuccess \|\| rv == cmUnkonwReason);
	646	+ //decoding after each encoding frame
	647	+ int len = 0;
	648	+ encToDecData (info, len);
	649	+ unsigned char* pData[3] = { NULL };
	650	+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
	651	+ iSkipedBytes = SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx,
	652	+ bVCLLoss);
	653	+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
	654	+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
	655	+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
	656	+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
	657	+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
	658	+ LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
	659	+ if (iSkipedBytes && bVCLLoss) {
	660	+ ASSERT_TRUE (dstBufInfo_.iBufferStatus == 0);
	661	+ }
	662	+ iIdx++;
	663	+ }
	664	+}
	665	+
	666	+TEST_P (EncodeDecodeTestAPI, SetOptionECFlag_ERROR_CON_SLICE_COPY) {
	667	+ SLTRMarkingFeedback m_LTR_Marking_Feedback;
	668	+ SLTRRecoverRequest m_LTR_Recover_Request;
	669	+ EncodeDecodeFileParamBase p = GetParam();
	670	+ prepareParam (p.width, p.height, p.frameRate);
	671	+ param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
	672	+ param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
	673	+ encoder_->Uninitialize();
	674	+ int rv = encoder_->InitializeExt (&param_);
	675	+ ASSERT_TRUE (rv == cmResultSuccess);
	676	+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
	677	+ int frameSize = p.width * p.height * 3 / 2;
	678	+ buf_.SetLength (frameSize);
	679	+ ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
	680	+ SFrameBSInfo info;
	681	+ memset (&info, 0, sizeof (SFrameBSInfo));
	682	+
	683	+ SSourcePicture pic;
	684	+ memset (&pic, 0, sizeof (SSourcePicture));
	685	+ pic.iPicWidth = p.width;
	686	+ pic.iPicHeight = p.height;
	687	+ pic.iColorFormat = videoFormatI420;
	688	+ pic.iStride[0] = pic.iPicWidth;
	689	+ pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
	690	+ pic.pData[0] = buf_.data();
	691	+ pic.pData[1] = pic.pData[0] + p.width * p.height;
	692	+ pic.pData[2] = pic.pData[1] + (p.width * p.height >> 2);
	693	+ int32_t iTraceLevel = WELS_LOG_QUIET;
	694	+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
	695	+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
	696	+ int32_t iSpsPpsIdAddition = 1;
	697	+ encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
	698	+ int32_t iIDRPeriod = 60;
	699	+ encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
	700	+ SLTRConfig sLtrConfigVal;
	701	+ sLtrConfigVal.bEnableLongTermReference = 1;
	702	+ sLtrConfigVal.iLTRRefNum = 1;
	703	+ encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
	704	+ int32_t iLtrPeriod = 2;
	705	+ encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
	706	+ int iIdx = 0;
	707	+ int iLossIdx = 0;
	708	+ int iSkipedBytes;
	709	+ bool bVCLLoss = false;
	710	+ while (iIdx <= p.numframes) {
	711	+ memset (buf_.data(), rand() % 256, frameSize);
	712	+ rv = encoder_->EncodeFrame (&pic, &info);
	713	+ if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) {
	714	+ ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
	715	+ }
	716	+ ASSERT_TRUE (rv == cmResultSuccess \|\| rv == cmUnkonwReason);
	717	+ //decoding after each encoding frame
	718	+ int len = 0;
	719	+ encToDecData (info, len);
	720	+ unsigned char* pData[3] = { NULL };
	721	+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
	722	+ iSkipedBytes = SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx,
	723	+ bVCLLoss);
	724	+ uint32_t uiEcIdc = rand() % 2 == 1 ? ERROR_CON_DISABLE : ERROR_CON_SLICE_COPY;
	725	+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
	726	+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
	727	+ m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
	728	+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
	729	+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
	730	+ LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv);
	731	+ LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
	732	+ iIdx++;
	733	+ }
	734	+}
	735	+
	736	+INSTANTIATE_TEST_CASE_P (EncodeDecodeTestBase, EncodeDecodeTestAPI,
	737	+ ::testing::ValuesIn (kFileParamArray));

1. add encoder-engine-decoder API UT for: IDR request, LTR request 2. add decoder api UT for EC: Disable/Enable EC 3. Fix a decoder bug when EC is disabled itoltalMbDec should be set to zero when encouter a new sequence/picture, even when EC is disabled.

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code