History

moving test cases to specific files to avoid the too long encode_decode_api_test.cpp

sijchen committed 10 years ago

Commit 46667581 parent f679da97 files · +3619 −3554Browse files

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

Unified · Split

test/api/decode_api_test.cpp+962−0
@@ -0,0 +1,962 @@
1#include <gtest/gtest.h>
2#include "codec_def.h"
3#include "utils/BufferedData.h"
4#include "utils/FileInputStream.h"
5#include "BaseDecoderTest.h"
6#include "BaseEncoderTest.h"
7#include "wels_common_defs.h"
8#include "utils/HashFunctions.h"
9#include <string>
10#include <vector>
11#include "encode_decode_api_test.h"
12using namespace WelsCommon;
13
14static void TestOutPutTrace (void* ctx, int level, const char* string) {
15 STraceUnit* pTraceUnit = (STraceUnit*) ctx;
16 EXPECT_LE (level, pTraceUnit->iTarLevel);
17}
18
19TEST_P (EncodeDecodeTestAPI, DecoderVclNal) {
20 EncodeDecodeFileParamBase p = GetParam();
21 prepareParamDefault (1, p.slicenum, p.width, p.height, p.frameRate, &param_);
22 encoder_->Uninitialize();
23 int rv = encoder_->InitializeExt (&param_);
24 ASSERT_TRUE (rv == cmResultSuccess);
25
26 int32_t iTraceLevel = WELS_LOG_QUIET;
27 encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
28 decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
29
30 InitialEncDec (p.width, p.height);
31
32 int iIdx = 0;
33 while (iIdx <= p.numframes) {
34
35 EncodeOneFrame (0);
36
37 //decoding after each encoding frame
38 int vclNal, len = 0;
39 encToDecData (info, len);
40 unsigned char* pData[3] = { NULL };
41 memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
42 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
43 ASSERT_TRUE (rv == cmResultSuccess);
44 rv = decoder_->GetOption (DECODER_OPTION_VCL_NAL, &vclNal);
45 EXPECT_EQ (vclNal, FEEDBACK_UNKNOWN_NAL); //no reconstruction, unknown return
46 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
47 ASSERT_TRUE (rv == cmResultSuccess);
48 rv = decoder_->GetOption (DECODER_OPTION_VCL_NAL, &vclNal);
49 EXPECT_EQ (vclNal, FEEDBACK_VCL_NAL);
50 iIdx++;
51 } //while
52 //ignore last frame
53}
54
55TEST_P (EncodeDecodeTestAPI, GetOptionFramenum) {
56 EncodeDecodeFileParamBase p = GetParam();
57 prepareParamDefault (1, p.slicenum, p.width, p.height, p.frameRate, &param_);
58 encoder_->Uninitialize();
59 int rv = encoder_->InitializeExt (&param_);
60 ASSERT_TRUE (rv == cmResultSuccess);
61
62 int32_t iTraceLevel = WELS_LOG_QUIET;
63 encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
64 decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
65
66 InitialEncDec (p.width, p.height);
67
68 int32_t iEncFrameNum = -1;
69 int32_t iDecFrameNum;
70 int iIdx = 0;
71 while (iIdx <= p.numframes) {
72 EncodeOneFrame (0);
73 //decoding after each encoding frame
74 int len = 0;
75 encToDecData (info, len);
76 unsigned char* pData[3] = { NULL };
77 memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
78 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
79 ASSERT_TRUE (rv == cmResultSuccess);
80 decoder_->GetOption (DECODER_OPTION_FRAME_NUM, &iDecFrameNum);
81 EXPECT_EQ (iDecFrameNum, -1);
82 iEncFrameNum++;
83 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
84 ASSERT_TRUE (rv == cmResultSuccess);
85 decoder_->GetOption (DECODER_OPTION_FRAME_NUM, &iDecFrameNum);
86 EXPECT_EQ (iEncFrameNum, iDecFrameNum);
87 iIdx++;
88 } //while
89 //ignore last frame
90}
91
92TEST_P (EncodeDecodeTestAPI, GetOptionIDR) {
93 EncodeDecodeFileParamBase p = GetParam();
94 prepareParamDefault (1, p.slicenum, p.width, p.height, p.frameRate, &param_);
95 encoder_->Uninitialize();
96 int rv = encoder_->InitializeExt (&param_);
97 ASSERT_TRUE (rv == cmResultSuccess);
98
99 //init for encoder
100 // I420: 1(Y) + 1/4(U) + 1/4(V)
101 int32_t iTraceLevel = WELS_LOG_QUIET;
102 encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
103 decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
104
105 InitialEncDec (p.width, p.height);
106
107 int32_t iEncCurIdrPicId = 0;
108 int32_t iDecCurIdrPicId;
109 int32_t iIDRPeriod = 1;
110 int32_t iSpsPpsIdAddition = 0;
111 int iIdx = 0;
112 while (iIdx <= p.numframes) {
113 iSpsPpsIdAddition = rand() %
114 2; //the current strategy supports more than 2 modes, but the switch between the modes>2 is not allowed
115 iIDRPeriod = (rand() % 150) + 1;
116 encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
117 encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
118
119 EncodeOneFrame (0);
120
121 if (info.eFrameType == videoFrameTypeIDR) {
122 iEncCurIdrPicId = iEncCurIdrPicId + 1;
123 }
124 //decoding after each encoding frame
125 int len = 0;
126 encToDecData (info, len);
127 unsigned char* pData[3] = { NULL };
128 memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
129 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
130 ASSERT_TRUE (rv == cmResultSuccess);
131 decoder_->GetOption (DECODER_OPTION_IDR_PIC_ID, &iDecCurIdrPicId);
132 EXPECT_EQ (iDecCurIdrPicId, iEncCurIdrPicId);
133 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
134 ASSERT_TRUE (rv == cmResultSuccess);
135 decoder_->GetOption (DECODER_OPTION_IDR_PIC_ID, &iDecCurIdrPicId);
136 EXPECT_EQ (iDecCurIdrPicId, iEncCurIdrPicId);
137 iIdx++;
138 } //while
139 //ignore last frame
140}
141
142TEST_P (EncodeDecodeTestAPI, InOutTimeStamp) {
143 EncodeDecodeFileParamBase p = GetParam();
144 prepareParamDefault (1, p.slicenum, p.width, p.height, p.frameRate, &param_);
145 encoder_->Uninitialize();
146 int rv = encoder_->InitializeExt (&param_);
147 ASSERT_TRUE (rv == cmResultSuccess);
148
149 InitialEncDec (p.width, p.height);
150 int32_t iTraceLevel = WELS_LOG_QUIET;
151 encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
152 decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
153 int32_t iSpsPpsIdAddition = 1;
154 encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
155 int32_t iIDRPeriod = 60;
156 encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
157 SLTRConfig sLtrConfigVal;
158 sLtrConfigVal.bEnableLongTermReference = 1;
159 sLtrConfigVal.iLTRRefNum = 1;
160 encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
161 int32_t iLtrPeriod = 2;
162 encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
163 int iIdx = 0;
164 int iSkipedBytes;
165 unsigned long long uiEncTimeStamp = 100;
166 while (iIdx <= p.numframes) {
167 EncodeOneFrame (1);
168 //decoding after each encoding frame
169 int len = 0;
170 encToDecData (info, len);
171 unsigned char* pData[3] = { NULL };
172 memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
173 uint32_t uiEcIdc = ERROR_CON_SLICE_COPY_CROSS_IDR_FREEZE_RES_CHANGE;
174 decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
175 dstBufInfo_.uiInBsTimeStamp = uiEncTimeStamp;
176 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
177 memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
178 dstBufInfo_.uiInBsTimeStamp = uiEncTimeStamp;
179 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
180 if (dstBufInfo_.iBufferStatus == 1) {
181 EXPECT_EQ (uiEncTimeStamp, dstBufInfo_.uiOutYuvTimeStamp);
182 }
183 iIdx++;
184 uiEncTimeStamp++;
185 }
186 (void) iSkipedBytes;
187}
188
189TEST_P (EncodeDecodeTestAPI, GetOptionTid_AVC_NOPREFIX) {
190 SLTRMarkingFeedback m_LTR_Marking_Feedback;
191 SLTRRecoverRequest m_LTR_Recover_Request;
192 m_LTR_Recover_Request.uiIDRPicId = 0;
193 EncodeDecodeFileParamBase p = GetParam();
194 prepareParamDefault (1, p.slicenum, p.width, p.height, p.frameRate, &param_);
195 param_.bPrefixNalAddingCtrl = false;
196 param_.iTemporalLayerNum = (rand() % 4) + 1;
197 encoder_->Uninitialize();
198 int rv = encoder_->InitializeExt (&param_);
199 ASSERT_TRUE (rv == cmResultSuccess);
200 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
201 InitialEncDec (p.width, p.height);
202 int32_t iTraceLevel = WELS_LOG_QUIET;
203 encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
204 decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
205 int32_t iSpsPpsIdAddition = 1;
206 encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
207 int32_t iIDRPeriod = 60;
208 encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
209 SLTRConfig sLtrConfigVal;
210 sLtrConfigVal.bEnableLongTermReference = 1;
211 sLtrConfigVal.iLTRRefNum = 1;
212 encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
213 int32_t iLtrPeriod = 2;
214 encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
215 int iIdx = 0;
216 int iLossIdx = 0;
217 bool bVCLLoss = false;
218 while (iIdx <= p.numframes) {
219 EncodeOneFrame (1);
220 if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) {
221 ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
222 }
223 //decoding after each encoding frame
224 int len = 0;
225 encToDecData (info, len);
226 unsigned char* pData[3] = { NULL };
227 memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
228 SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss);
229 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
230 int iTid = -1;
231 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
232 if (iTid != -1) {
233 ASSERT_EQ (iTid, 0);
234 }
235 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
236 LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true);
237 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
238 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
239 std::vector<SLostSim>::iterator iter = m_SLostSim.begin();
240 bool bHasVCL = false;
241 for (unsigned int k = 0; k < m_SLostSim.size(); k++) {
242 if (IS_VCL_NAL (iter->eNalType, 0) && iter->isLost == false) {
243 bHasVCL = true;
244 break;
245 }
246 iter++;
247 }
248 (void) bHasVCL;
249 if (iTid != -1) {
250 ASSERT_EQ (iTid, 0);
251 }
252 LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true);
253 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
254 iIdx++;
255 }
256}
257
258TEST_P (EncodeDecodeTestAPI, GetOptionTid_AVC_WITH_PREFIX_NOLOSS) {
259 SLTRMarkingFeedback m_LTR_Marking_Feedback;
260 SLTRRecoverRequest m_LTR_Recover_Request;
261 m_LTR_Recover_Request.uiIDRPicId = 0;
262 EncodeDecodeFileParamBase p = GetParam();
263 prepareParamDefault (1, p.slicenum, p.width, p.height, p.frameRate, &param_);
264 param_.bPrefixNalAddingCtrl = true;
265 param_.iTemporalLayerNum = (rand() % 4) + 1;
266 param_.iSpatialLayerNum = 1;
267 encoder_->Uninitialize();
268 int rv = encoder_->InitializeExt (&param_);
269 ASSERT_TRUE (rv == cmResultSuccess);
270 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
271
272 InitialEncDec (p.width, p.height);
273 int32_t iTraceLevel = WELS_LOG_QUIET;
274 encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
275 decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
276 int32_t iSpsPpsIdAddition = 1;
277 encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
278 int32_t iIDRPeriod = 60;
279 encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
280 SLTRConfig sLtrConfigVal;
281 sLtrConfigVal.bEnableLongTermReference = 1;
282 sLtrConfigVal.iLTRRefNum = 1;
283 encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
284 int32_t iLtrPeriod = 2;
285 encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
286 int iIdx = 0;
287 while (iIdx <= p.numframes) {
288 EncodeOneFrame (1);
289 if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) {
290 ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
291 }
292 //decoding after each encoding frame
293 int len = 0;
294 encToDecData (info, len);
295 unsigned char* pData[3] = { NULL };
296 memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
297 ExtractDidNal (&info, len, &m_SLostSim, 0);
298 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
299 int iTid = -1;
300 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
301 ASSERT_EQ (iTid, -1);
302 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
303 LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true);
304 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
305 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
306 ASSERT_EQ (iTid, info.sLayerInfo[0].uiTemporalId);
307 LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true);
308 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
309 iIdx++;
310 }
311}
312
313TEST_P (EncodeDecodeTestAPI, GetOptionTid_SVC_L1_NOLOSS) {
314 SLTRMarkingFeedback m_LTR_Marking_Feedback;
315 SLTRRecoverRequest m_LTR_Recover_Request;
316 m_LTR_Recover_Request.uiIDRPicId = 0;
317 EncodeDecodeFileParamBase p = GetParam();
318 prepareParamDefault (2, p.slicenum, p.width, p.height, p.frameRate, &param_);
319 param_.iTemporalLayerNum = (rand() % 4) + 1;
320 param_.iSpatialLayerNum = 2;
321 encoder_->Uninitialize();
322 int rv = encoder_->InitializeExt (&param_);
323 ASSERT_TRUE (rv == cmResultSuccess);
324 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
325
326 InitialEncDec (p.width, p.height);
327 int32_t iTraceLevel = WELS_LOG_QUIET;
328 encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
329 decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
330 int32_t iSpsPpsIdAddition = 1;
331 encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
332 int32_t iIDRPeriod = 60;
333 encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
334 SLTRConfig sLtrConfigVal;
335 sLtrConfigVal.bEnableLongTermReference = 1;
336 sLtrConfigVal.iLTRRefNum = 1;
337 encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
338 int32_t iLtrPeriod = 2;
339 encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
340 int iIdx = 0;
341 while (iIdx <= p.numframes) {
342 EncodeOneFrame (1);
343 if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) {
344 ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
345 }
346 //decoding after each encoding frame
347 int len = 0;
348 encToDecData (info, len);
349 unsigned char* pData[3] = { NULL };
350 memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
351 ExtractDidNal (&info, len, &m_SLostSim, 1);
352 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
353 int iTid = -1;
354 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
355 ASSERT_EQ (iTid, -1);
356 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
357 LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true);
358 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
359 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
360 ASSERT_EQ (iTid, info.sLayerInfo[0].uiTemporalId);
361 LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true);
362 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
363 iIdx++;
364 }
365}
366
367
368
369TEST_P (EncodeDecodeTestAPI, SetOption_Trace) {
370 SLTRMarkingFeedback m_LTR_Marking_Feedback;
371 SLTRRecoverRequest m_LTR_Recover_Request;
372 m_LTR_Recover_Request.uiIDRPicId = 0;
373 EncodeDecodeFileParamBase p = GetParam();
374 prepareParamDefault (1, p.slicenum, p.width, p.height, p.frameRate, &param_);
375 param_.iSpatialLayerNum = 1;
376
377 int rv = encoder_->InitializeExt (&param_);
378 ASSERT_TRUE (rv == cmResultSuccess);
379 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
380
381 InitialEncDec (p.width, p.height);
382 int32_t iTraceLevel = WELS_LOG_QUIET;
383 pFunc = TestOutPutTrace;
384 pTraceInfo = &sTrace;
385 sTrace.iTarLevel = iTraceLevel;
386 encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
387 decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
388 encoder_->SetOption (ENCODER_OPTION_TRACE_CALLBACK, &pFunc);
389 encoder_->SetOption (ENCODER_OPTION_TRACE_CALLBACK_CONTEXT, &pTraceInfo);
390 decoder_->SetOption (DECODER_OPTION_TRACE_CALLBACK, &pFunc);
391 decoder_->SetOption (DECODER_OPTION_TRACE_CALLBACK_CONTEXT, &pTraceInfo);
392
393
394 int32_t iSpsPpsIdAddition = 1;
395 encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
396 int32_t iIDRPeriod = 60;
397 encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
398 SLTRConfig sLtrConfigVal;
399 sLtrConfigVal.bEnableLongTermReference = 1;
400 sLtrConfigVal.iLTRRefNum = 1;
401 encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
402 int32_t iLtrPeriod = 2;
403 encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
404 int iIdx = 0;
405 int iLossIdx = 0;
406 bool bVCLLoss = false;
407 while (iIdx <= p.numframes) {
408 iTraceLevel = rand() % 33;
409 sTrace.iTarLevel = iTraceLevel;
410 encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
411 decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
412 EncodeOneFrame (1);
413 if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) {
414 ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
415 }
416 //decoding after each encoding frame
417 int len = 0;
418 encToDecData (info, len);
419 unsigned char* pData[3] = { NULL };
420 memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
421 ExtractDidNal (&info, len, &m_SLostSim, 0);
422 SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss);
423 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
424 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
425 LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true);
426 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
427 LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true);
428 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
429 iIdx++;
430 }
431}
432
433TEST_P (EncodeDecodeTestAPI, SetOption_Trace_NULL) {
434 SLTRMarkingFeedback m_LTR_Marking_Feedback;
435 SLTRRecoverRequest m_LTR_Recover_Request;
436 m_LTR_Recover_Request.uiIDRPicId = 0;
437 EncodeDecodeFileParamBase p = GetParam();
438 prepareParamDefault (1, p.slicenum, p.width, p.height, p.frameRate, &param_);
439 param_.iSpatialLayerNum = 1;
440 int rv = encoder_->InitializeExt (&param_);
441 ASSERT_TRUE (rv == cmResultSuccess);
442 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
443
444 InitialEncDec (p.width, p.height);
445
446 int32_t iTraceLevel = WELS_LOG_QUIET;
447 pFunc = NULL;
448 pTraceInfo = NULL;
449 encoder_->SetOption (ENCODER_OPTION_TRACE_CALLBACK, &pFunc);
450 encoder_->SetOption (ENCODER_OPTION_TRACE_CALLBACK_CONTEXT, &pTraceInfo);
451 decoder_->SetOption (DECODER_OPTION_TRACE_CALLBACK, &pFunc);
452 decoder_->SetOption (DECODER_OPTION_TRACE_CALLBACK_CONTEXT, &pTraceInfo);
453 encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
454 decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
455
456 int32_t iSpsPpsIdAddition = 1;
457 encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition);
458 int32_t iIDRPeriod = 60;
459 encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
460 SLTRConfig sLtrConfigVal;
461 sLtrConfigVal.bEnableLongTermReference = 1;
462 sLtrConfigVal.iLTRRefNum = 1;
463 encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal);
464 int32_t iLtrPeriod = 2;
465 encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod);
466 int iIdx = 0;
467 int iLossIdx = 0;
468 bool bVCLLoss = false;
469 while (iIdx <= p.numframes) {
470 iTraceLevel = rand() % 33;
471 encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
472 decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
473 EncodeOneFrame (1);
474 if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) {
475 ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR);
476 }
477 //decoding after each encoding frame
478 int len = 0;
479 encToDecData (info, len);
480 unsigned char* pData[3] = { NULL };
481 memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
482 ExtractDidNal (&info, len, &m_SLostSim, 0);
483 SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss);
484 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
485 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
486 LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true);
487 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
488 LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true);
489 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
490 iIdx++;
491 }
492}
493
494
495
496
497class DecodeCrashTestAPI : public ::testing::TestWithParam<EncodeDecodeFileParamBase>, public EncodeDecodeTestBase {
498 public:
499 uint8_t iRandValue;
500 public:
501 void SetUp() {
502 EncodeDecodeTestBase::SetUp();
503 ucBuf_ = NULL;
504 ucBuf_ = new unsigned char [1000000];
505 ASSERT_TRUE (ucBuf_ != NULL);
506 }
507
508 void TearDown() {
509 EncodeDecodeTestBase::TearDown();
510 if (NULL != ucBuf_) {
511 delete[] ucBuf_;
512 ucBuf_ = NULL;
513 }
514 ASSERT_TRUE (ucBuf_ == NULL);
515 }
516
517 void prepareParam (int iLayerNum, int iSliceNum, int width, int height, float framerate, SEncParamExt* pParam) {
518 memset (pParam, 0, sizeof (SEncParamExt));
519 EncodeDecodeTestBase::prepareParam (iLayerNum, iSliceNum, width, height, framerate, pParam);
520 }
521
522 void prepareEncDecParam (const EncodeDecodeFileParamBase EncDecFileParam);
523 void EncodeOneFrame() {
524 int frameSize = EncPic.iPicWidth * EncPic.iPicHeight * 3 / 2;
525 memset (buf_.data(), iRandValue, (frameSize >> 2));
526 memset (buf_.data() + (frameSize >> 2), rand() % 256, (frameSize - (frameSize >> 2)));
527 int rv = encoder_->EncodeFrame (&EncPic, &info);
528 ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnknownReason);
529 }
530 protected:
531 unsigned char* ucBuf_;
532};
533
534void DecodeCrashTestAPI::prepareEncDecParam (const EncodeDecodeFileParamBase EncDecFileParam) {
535 // for encoder
536 // I420: 1(Y) + 1/4(U) + 1/4(V)
537 int frameSize = EncDecFileParam.width * EncDecFileParam.height * 3 / 2;
538
539 buf_.SetLength (frameSize);
540 ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
541
542 memset (&EncPic, 0, sizeof (SSourcePicture));
543 EncPic.iPicWidth = EncDecFileParam.width;
544 EncPic.iPicHeight = EncDecFileParam.height;
545 EncPic.iColorFormat = videoFormatI420;
546 EncPic.iStride[0] = EncPic.iPicWidth;
547 EncPic.iStride[1] = EncPic.iStride[2] = EncPic.iPicWidth >> 1;
548 EncPic.pData[0] = buf_.data();
549 EncPic.pData[1] = EncPic.pData[0] + EncDecFileParam.width * EncDecFileParam.height;
550 EncPic.pData[2] = EncPic.pData[1] + (EncDecFileParam.width * EncDecFileParam.height >> 2);
551
552 //for decoder
553 memset (&info, 0, sizeof (SFrameBSInfo));
554
555 //set a fixed random value
556 iRandValue = rand() % 256;
557}
558
559struct EncodeDecodeParamBase {
560 int width;
561 int height;
562 float frameRate;
563 int iTarBitrate;
564};
565
566#define NUM_OF_POSSIBLE_RESOLUTION (9)
567static const EncodeDecodeParamBase kParamArray[] = {
568 {160, 90, 6.0f, 250000},
569 {90, 160, 6.0f, 250000},
570 {320, 180, 12.0f, 500000},
571 {180, 320, 12.0f, 500000},
572 {480, 270, 12.0f, 600000},
573 {270, 480, 12.0f, 600000},
574 {640, 360, 24.0f, 800000},
575 {360, 640, 24.0f, 800000},
576 {1280, 720, 24.0f, 1000000},
577};
578
579//#define DEBUG_FILE_SAVE_CRA
580TEST_F (DecodeCrashTestAPI, DecoderCrashTest) {
581 uint32_t uiGet;
582 encoder_->Uninitialize();
583
584 //do tests until crash
585 unsigned int uiLoopRound = 0;
586 unsigned char* pucBuf = ucBuf_;
587 int iDecAuSize;
588#ifdef DEBUG_FILE_SAVE_CRA
589 //open file to save tested BS
590 FILE* fDataFile = fopen ("test_crash.264", "wb");
591 FILE* fLenFile = fopen ("test_crash_len.log", "w");
592 int iFileSize = 0;
593#endif
594
595 //set eCurStrategy for one test
596 EParameterSetStrategy eCurStrategy = CONSTANT_ID;
597 switch (rand() % 7) {
598 case 1:
599 eCurStrategy = INCREASING_ID;
600 break;
601 case 2:
602 eCurStrategy = SPS_LISTING;
603 break;
604 case 3:
605 eCurStrategy = SPS_LISTING_AND_PPS_INCREASING;
606 break;
607 case 6:
608 eCurStrategy = SPS_PPS_LISTING;
609 break;
610 default:
611 //using the initial value
612 break;
613 }
614
615 do {
616 int iTotalFrameNum = (rand() % 100) + 1;
617 int iSeed = rand() % NUM_OF_POSSIBLE_RESOLUTION;
618 EncodeDecodeParamBase p = kParamArray[iSeed];
619#ifdef DEBUG_FILE_SAVE_CRA
620 printf ("using param set %d in loop %d\n", iSeed, uiLoopRound);
621#endif
622 //Initialize Encoder
623 prepareParam (1, 1, p.width, p.height, p.frameRate, &param_);
624 param_.iRCMode = RC_TIMESTAMP_MODE;
625 param_.iTargetBitrate = p.iTarBitrate;
626 param_.uiIntraPeriod = 0;
627 param_.eSpsPpsIdStrategy = eCurStrategy;
628 param_.bEnableBackgroundDetection = true;
629 param_.bEnableSceneChangeDetect = (rand() % 3) ? true : false;
630 param_.bPrefixNalAddingCtrl = (rand() % 2) ? true : false;
631 param_.iEntropyCodingModeFlag = 0;
632 param_.bEnableFrameSkip = true;
633 param_.iMultipleThreadIdc = 0;
634 param_.sSpatialLayers[0].iSpatialBitrate = p.iTarBitrate;
635 param_.sSpatialLayers[0].iMaxSpatialBitrate = p.iTarBitrate << 1;
636 param_.sSpatialLayers[0].sSliceArgument.uiSliceMode = (rand() % 2) ? SM_SIZELIMITED_SLICE : SM_SINGLE_SLICE;
637 if (param_.sSpatialLayers[0].sSliceArgument.uiSliceMode == SM_SIZELIMITED_SLICE) {
638 param_.sSpatialLayers[0].sSliceArgument.uiSliceSizeConstraint = 1400;
639 param_.uiMaxNalSize = 1400;
640 } else {
641 param_.sSpatialLayers[0].sSliceArgument.uiSliceSizeConstraint = 0;
642 param_.uiMaxNalSize = 0;
643 }
644
645 int rv = encoder_->InitializeExt (&param_);
646 ASSERT_TRUE (rv == cmResultSuccess);
647 decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
648 EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_SLICE_COPY); //default value should be ERROR_CON_SLICE_COPY
649 int32_t iTraceLevel = WELS_LOG_QUIET;
650 encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
651 decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
652
653 //Start for enc/dec
654 int iIdx = 0;
655 unsigned char* pData[3] = { NULL };
656
657 EncodeDecodeFileParamBase pInput; //to conform with old functions
658 pInput.width = p.width;
659 pInput.height = p.height;
660 pInput.frameRate = p.frameRate;
661 prepareEncDecParam (pInput);
662 while (iIdx++ < iTotalFrameNum) { // loop in frame
663 EncodeOneFrame();
664#ifdef DEBUG_FILE_SAVE_CRA
665 //reset file if file size large
666 if ((info.eFrameType == videoFrameTypeIDR) && (iFileSize >= (1 << 25))) {
667 fclose (fDataFile);
668 fDataFile = fopen ("test_crash.264", "wb");
669 iFileSize = 0;
670 decoder_->Uninitialize();
671
672 SDecodingParam decParam;
673 memset (&decParam, 0, sizeof (SDecodingParam));
674 decParam.uiTargetDqLayer = UCHAR_MAX;
675 decParam.eEcActiveIdc = ERROR_CON_SLICE_COPY;
676 decParam.sVideoProperty.eVideoBsType = VIDEO_BITSTREAM_DEFAULT;
677
678 rv = decoder_->Initialize (&decParam);
679 ASSERT_EQ (0, rv);
680 }
681#endif
682 if (info.eFrameType == videoFrameTypeSkip)
683 continue;
684 //deal with packets
685 unsigned char* pBsBuf;
686 iDecAuSize = 0;
687 pucBuf = ucBuf_; //init buf start pos for decoder usage
688 for (int iLayerNum = 0; iLayerNum < info.iLayerNum; iLayerNum++) {
689 SLayerBSInfo* pLayerBsInfo = &info.sLayerInfo[iLayerNum];
690 pBsBuf = info.sLayerInfo[iLayerNum].pBsBuf;
691 int iTotalNalCnt = pLayerBsInfo->iNalCount;
692 for (int iNalCnt = 0; iNalCnt < iTotalNalCnt; iNalCnt++) { //loop in NAL
693 int iPacketSize = pLayerBsInfo->pNalLengthInByte[iNalCnt];
694 //packet loss
695 int iLossRateRange = (uiLoopRound % 100) + 1; //1-100
696 int iLossRate = (rand() % iLossRateRange);
697 bool bPacketLost = (rand() % 101) > (100 -
698 iLossRate); // [0, (100-iLossRate)] indicates NO LOSS, (100-iLossRate, 100] indicates LOSS
699 if (!bPacketLost) { //no loss
700 memcpy (pucBuf, pBsBuf, iPacketSize);
701 pucBuf += iPacketSize;
702 iDecAuSize += iPacketSize;
703 }
704#ifdef DEBUG_FILE_SAVE_CRA
705 else {
706 printf ("lost packet size=%d at frame-type=%d at loss rate %d (%d)\n", iPacketSize, info.eFrameType, iLossRate,
707 iLossRateRange);
708 }
709#endif
710 //update bs info
711 pBsBuf += iPacketSize;
712 } //nal
713 } //layer
714
715#ifdef DEBUG_FILE_SAVE_CRA
716 //save to file
717 fwrite (ucBuf_, 1, iDecAuSize, fDataFile);
718 fflush (fDataFile);
719 iFileSize += iDecAuSize;
720
721 //save to len file
722 unsigned long ulTmp[4];
723 ulTmp[0] = ulTmp[1] = ulTmp[2] = iIdx;
724 ulTmp[3] = iDecAuSize;
725 fwrite (ulTmp, sizeof (unsigned long), 4, fLenFile); // index, timeStamp, data size
726 fflush (fLenFile);
727#endif
728
729 //decode
730 pData[0] = pData[1] = pData[2] = 0;
731 memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
732
733 rv = decoder_->DecodeFrame2 (ucBuf_, iDecAuSize, pData, &dstBufInfo_);
734 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
735 //guarantee decoder EC status
736 decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
737 EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_SLICE_COPY);
738 } //frame
739 uiLoopRound ++;
740 if (uiLoopRound >= (1 << 30))
741 uiLoopRound = 0;
742#ifdef DEBUG_FILE_SAVE_CRA
743 if (uiLoopRound % 100 == 0)
744 printf ("run %d times.\n", uiLoopRound);
745 } while (1); //while (iLoopRound<100);
746 fclose (fDataFile);
747 fclose (fLenFile);
748#else
749 }
750 while (uiLoopRound < 10);
751#endif
752
753}
754
755const uint32_t kiTotalLayer = 3; //DO NOT CHANGE!
756const uint32_t kiSliceNum = 2; //DO NOT CHANGE!
757const uint32_t kiWidth = 160; //DO NOT CHANGE!
758const uint32_t kiHeight = 96; //DO NOT CHANGE!
759const uint32_t kiFrameRate = 12; //DO NOT CHANGE!
760const uint32_t kiFrameNum = 100; //DO NOT CHANGE!
761const char* pHashStr[] = { //DO NOT CHANGE!
762 "585663f78cadb70d9c9f179b9b53b90ffddf3178",
763 "f350001c333902029800bd291fbed915a4bdf19a",
764 "eb9d853b7daec03052c4850027ac94adc84c3a7e"
765};
766
767class DecodeParseAPI : public ::testing::TestWithParam<EncodeDecodeFileParamBase>, public EncodeDecodeTestBase {
768 public:
769 void SetUp() {
770 SHA1Reset (&ctx_);
771 EncodeDecodeTestBase::SetUp();
772
773 if (decoder_)
774 decoder_->Uninitialize();
775 SDecodingParam decParam;
776 memset (&decParam, 0, sizeof (SDecodingParam));
777 decParam.uiTargetDqLayer = UCHAR_MAX;
778 decParam.eEcActiveIdc = ERROR_CON_SLICE_COPY;
779 decParam.bParseOnly = true;
780 decParam.sVideoProperty.eVideoBsType = VIDEO_BITSTREAM_DEFAULT;
781
782 int rv = decoder_->Initialize (&decParam);
783 ASSERT_EQ (0, rv);
784 memset (&BsInfo_, 0, sizeof (SParserBsInfo));
785 fYuv_ = fopen ("./res/CiscoVT2people_160x96_6fps.yuv", "rb");
786 ASSERT_TRUE (fYuv_ != NULL);
787 iWidth_ = kiWidth;
788 iHeight_ = kiHeight;
789 }
790 void TearDown() {
791 EncodeDecodeTestBase::TearDown();
792 fclose (fYuv_);
793 }
794
795 void prepareEncDecParam (const EncodeDecodeFileParamBase p) {
796 EncodeDecodeTestBase::prepareEncDecParam (p);
797 unsigned char* pTmpPtr = BsInfo_.pDstBuff; //store for restore
798 memset (&BsInfo_, 0, sizeof (SParserBsInfo));
799 BsInfo_.pDstBuff = pTmpPtr;
800 }
801
802 void EncodeOneFrame (int iIdx) {
803 int iFrameSize = iWidth_ * iHeight_ * 3 / 2;
804 int iSize = (int) fread (buf_.data(), sizeof (char), iFrameSize, fYuv_);
805 if (feof (fYuv_) || iSize != iFrameSize) {
806 rewind (fYuv_);
807 iSize = (int) fread (buf_.data(), sizeof (char), iFrameSize, fYuv_);
808 ASSERT_TRUE (iSize == iFrameSize);
809 }
810 int rv = encoder_->EncodeFrame (&EncPic, &info);
811 ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnknownReason);
812 }
813
814 void prepareParam (int iLayerNum, int iSliceNum, int width, int height, float framerate, SEncParamExt* pParam) {
815 memset (pParam, 0, sizeof (SEncParamExt));
816 EncodeDecodeTestBase::prepareParam (iLayerNum, iSliceNum, width, height, framerate, pParam);
817 }
818
819 protected:
820 SParserBsInfo BsInfo_;
821 FILE* fYuv_;
822 int iWidth_;
823 int iHeight_;
824 SHA1Context ctx_;
825};
826
827//#define DEBUG_FILE_SAVE
828TEST_F (DecodeParseAPI, ParseOnly_General) {
829 EncodeDecodeFileParamBase p;
830 p.width = iWidth_;
831 p.height = iHeight_;
832 p.frameRate = kiFrameRate;
833 p.numframes = kiFrameNum;
834 prepareParam (kiTotalLayer, kiSliceNum, p.width, p.height, p.frameRate, &param_);
835 param_.iSpatialLayerNum = kiTotalLayer;
836 encoder_->Uninitialize();
837 int rv = encoder_->InitializeExt (&param_);
838 ASSERT_TRUE (rv == 0);
839 int32_t iTraceLevel = WELS_LOG_QUIET;
840 encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
841 decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
842 uint32_t uiTargetLayerId = rand() % kiTotalLayer; //run only once
843#ifdef DEBUG_FILE_SAVE
844 FILE* fDec = fopen ("output.264", "wb");
845 FILE* fEnc = fopen ("enc.264", "wb");
846 FILE* fExtract = fopen ("extract.264", "wb");
847#endif
848 if (uiTargetLayerId < kiTotalLayer) { //should always be true
849 //Start for enc
850 int iLen = 0;
851 prepareEncDecParam (p);
852 int iFrame = 0;
853
854 while (iFrame < p.numframes) {
855 //encode
856 EncodeOneFrame (iFrame);
857 //extract target layer data
858 encToDecData (info, iLen);
859#ifdef DEBUG_FILE_SAVE
860 fwrite (info.sLayerInfo[0].pBsBuf, iLen, 1, fEnc);
861#endif
862 ExtractDidNal (&info, iLen, &m_SLostSim, uiTargetLayerId);
863#ifdef DEBUG_FILE_SAVE
864 fwrite (info.sLayerInfo[0].pBsBuf, iLen, 1, fExtract);
865#endif
866 //parseonly
867 //BsInfo_.pDstBuff = new unsigned char [1000000];
868 rv = decoder_->DecodeParser (info.sLayerInfo[0].pBsBuf, iLen, &BsInfo_);
869 EXPECT_TRUE (rv == 0);
870 EXPECT_TRUE (BsInfo_.iNalNum == 0);
871 rv = decoder_->DecodeParser (NULL, 0, &BsInfo_);
872 EXPECT_TRUE (rv == 0);
873 EXPECT_TRUE (BsInfo_.iNalNum != 0);
874 //get final output bs
875 iLen = 0;
876 int i = 0;
877 while (i < BsInfo_.iNalNum) {
878 iLen += BsInfo_.iNalLenInByte[i];
879 i++;
880 }
881#ifdef DEBUG_FILE_SAVE
882 fwrite (BsInfo_.pDstBuff, iLen, 1, fDec);
883#endif
884 SHA1Input (&ctx_, BsInfo_.pDstBuff, iLen);
885 iFrame++;
886 }
887 //calculate final SHA1 value
888 unsigned char digest[SHA_DIGEST_LENGTH];
889 SHA1Result (&ctx_, digest);
890 if (!HasFatalFailure()) {
891 CompareHash (digest, pHashStr[uiTargetLayerId]);
892 }
893 } //while
894#ifdef DEBUG_FILE_SAVE
895 fclose (fEnc);
896 fclose (fExtract);
897 fclose (fDec);
898#endif
899}
900
901//This case is for one layer only, for incomplete frame input
902//First slice is loss for random one picture with 2 slices per pic
903TEST_F (DecodeParseAPI, ParseOnly_SpecSliceLoss) {
904 int32_t iLayerNum = 1;
905 int32_t iSliceNum = 2;
906 EncodeDecodeFileParamBase p;
907 p.width = iWidth_;
908 p.height = iHeight_;
909 p.frameRate = kiFrameRate;
910 p.numframes = 5;
911 prepareParam (iLayerNum, iSliceNum, p.width, p.height, p.frameRate, &param_);
912 param_.iSpatialLayerNum = iLayerNum;
913 encoder_->Uninitialize();
914 int rv = encoder_->InitializeExt (&param_);
915 ASSERT_TRUE (rv == 0);
916 int32_t iTraceLevel = WELS_LOG_QUIET;
917 encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
918 decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
919
920 int32_t iMissedPicNum = rand() % (p.numframes - 1) + 1; //IDR no loss
921 //Start for enc
922 int iLen = 0;
923 uint32_t uiGet;
924 prepareEncDecParam (p);
925 int iFrame = 0;
926
927 while (iFrame < p.numframes) {
928 //encode
929 EncodeOneFrame (iFrame);
930 //parseonly
931 if (iFrame == iMissedPicNum) { //make current frame partly missing
932 //Frame: P, first slice loss
933 int32_t iTotalSliceSize = 0;
934 encToDecSliceData (0, 0, info, iTotalSliceSize); //slice 1 lost
935 encToDecSliceData (0, 1, info, iLen); //slice 2
936 decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
937 EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_DISABLE);
938 rv = decoder_->DecodeParser (info.sLayerInfo[0].pBsBuf + iTotalSliceSize, iLen, &BsInfo_);
939 EXPECT_TRUE (rv == 0);
940 EXPECT_TRUE (BsInfo_.iNalNum == 0);
941 rv = decoder_->DecodeParser (NULL, 0, &BsInfo_);
942 EXPECT_TRUE (rv != 0);
943 } else { //normal frame, complete
944 encToDecData (info, iLen);
945 rv = decoder_->DecodeParser (info.sLayerInfo[0].pBsBuf, iLen, &BsInfo_);
946 EXPECT_TRUE (rv == 0); //parse correct
947 EXPECT_TRUE (BsInfo_.iNalNum == 0);
948 rv = decoder_->DecodeParser (NULL, 0, &BsInfo_);
949 if (iFrame < iMissedPicNum) { //correct frames, all OK with output
950 EXPECT_TRUE (rv == 0);
951 EXPECT_TRUE (BsInfo_.iNalNum != 0);
952 } else { //(iFrame > iMissedPicNum), should output nothing as error
953 EXPECT_TRUE (rv != 0);
954 EXPECT_TRUE (BsInfo_.iNalNum == 0);
955 }
956 }
957 iFrame++;
958 } //while
959}
960
961
962

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