1 #include <gtest/gtest.h>
2 #include <stdlib.h>
3 #include "codec_api.h"
4 #include "codec_app_def.h"
5 #include "svc_enc_slice_segment.h"
6 #include "test_stdint.h"
7 #include "utils/FileInputStream.h"
8 //TODO: consider using BaseEncoderTest class from #include "../BaseEncoderTest.h"
9
10 class EncoderInterfaceTest : public ::testing::Test {
11 #define MB_SIZE (16)
12 #define MAX_WIDTH (3840)
13 #define MAX_HEIGHT (2160)
14 #define VALID_SIZE(iSize) (((iSize)>16)?(iSize):16)
15 #define MEM_VARY_SIZE (512)
16 #define IMAGE_VARY_SIZE (512)
17 #define TEST_FRAMES (30)
18
19 #define NAL_HEADER_BYTES (4)
20 #define NAL_TYPE (0x0F)
21 #define SPS_NAL_TYPE (7)
22 #define PPS_NAL_TYPE (8)
23 #define SUBSETSPS_NAL_TYPE (15)
24 #define GET_NAL_TYPE(pNalStart) (*(pNalStart+NAL_HEADER_BYTES) & NAL_TYPE)
25 #define IS_PARASET(iNalType) ((iNalType==SPS_NAL_TYPE) || (iNalType==PPS_NAL_TYPE) || (iNalType==SUBSETSPS_NAL_TYPE))
26
27 public:
SetUp()28 virtual void SetUp() {
29 int rv = WelsCreateSVCEncoder (&pPtrEnc);
30 ASSERT_EQ (0, rv);
31 ASSERT_TRUE (pPtrEnc != NULL);
32
33 unsigned int uiTraceLevel = WELS_LOG_ERROR;
34 pPtrEnc->SetOption (ENCODER_OPTION_TRACE_LEVEL, &uiTraceLevel);
35
36 pParamExt = new SEncParamExt();
37 ASSERT_TRUE (pParamExt != NULL);
38
39 pSrcPic = new SSourcePicture;
40 ASSERT_TRUE (pSrcPic != NULL);
41
42 pOption = new SEncParamExt();
43 ASSERT_TRUE (pOption != NULL);
44
45 pYUV = NULL;
46 m_iWidth = MAX_WIDTH;
47 m_iHeight = MAX_HEIGHT;
48 m_iPicResSize = m_iWidth * m_iHeight * 3 >> 1;
49 pYUV = new unsigned char [m_iPicResSize];
50 ASSERT_TRUE (pYUV != NULL);
51 }
52
TearDown()53 virtual void TearDown() {
54 delete pParamExt;
55 delete pOption;
56 delete pSrcPic;
57 delete []pYUV;
58 if (pPtrEnc) {
59 WelsDestroySVCEncoder (pPtrEnc);
60 pPtrEnc = NULL;
61 }
62 }
63
64 void InitializeParamExt();
65 void SetRandomParams();
66 void TemporalLayerSettingTest();
67 void MemoryCheckTest();
68 void EncodeOneFrame (SEncParamBase* pEncParamBase);
69 void PrepareOneSrcFrame();
70 void EncodeOneIDRandP (ISVCEncoder* pPtrEnc);
71 void ChangeResolutionAndCheckStatistics (const SEncParamBase& sEncParamBase, SEncoderStatistics* pEncoderStatistics);
72
73 public:
74 ISVCEncoder* pPtrEnc;
75 SEncParamExt* pParamExt;
76 SSourcePicture* pSrcPic;
77 SEncParamExt* pOption;
78 unsigned char* pYUV;
79 SFrameBSInfo sFbi;
80
81 int m_iWidth;
82 int m_iHeight;
83 int m_iPicResSize;
84 };
85
PrepareOneSrcFrame()86 void EncoderInterfaceTest::PrepareOneSrcFrame() {
87 pSrcPic->iColorFormat = videoFormatI420;
88 pSrcPic->uiTimeStamp = 0;
89 pSrcPic->iPicWidth = pParamExt->iPicWidth;
90 pSrcPic->iPicHeight = pParamExt->iPicHeight;
91 pSrcPic->iPicWidth = VALID_SIZE (pParamExt->iPicWidth);
92 pSrcPic->iPicHeight = VALID_SIZE (pParamExt->iPicHeight);
93 m_iWidth = pSrcPic->iPicWidth;
94 m_iHeight = pSrcPic->iPicHeight;
95 m_iPicResSize = m_iWidth * m_iHeight * 3 >> 1;
96
97 pYUV[0] = rand() % 256;
98 for (int i = 1; i < m_iPicResSize; i++) {
99 if ((i % 256) == 0)
100 pYUV[i] = rand() % 256;
101 else
102 pYUV[i] = (pYUV[i - 1] + (rand() % 3) - 1) & 0xff;
103 }
104 pSrcPic->iStride[0] = m_iWidth;
105 pSrcPic->iStride[1] = pSrcPic->iStride[2] = pSrcPic->iStride[0] >> 1;
106
107 pSrcPic->pData[0] = pYUV;
108 pSrcPic->pData[1] = pSrcPic->pData[0] + (m_iWidth * m_iHeight);
109 pSrcPic->pData[2] = pSrcPic->pData[1] + (m_iWidth * m_iHeight >> 2);
110
111 memset (&sFbi, 0, sizeof (SFrameBSInfo));
112 }
113
EncodeOneFrame(SEncParamBase * pEncParamBase)114 void EncoderInterfaceTest::EncodeOneFrame (SEncParamBase* pEncParamBase) {
115 int iResult;
116 iResult = pPtrEnc->Initialize (pEncParamBase);
117 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
118 PrepareOneSrcFrame();
119 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
120 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
121 EXPECT_EQ (sFbi.eFrameType, static_cast<int> (videoFrameTypeIDR));
122
123 iResult = pPtrEnc->GetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_BASE, pEncParamBase);
124 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
125
126 pPtrEnc->Uninitialize();
127 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
128 }
129
EncodeOneIDRandP(ISVCEncoder * pPtrEnc)130 void EncoderInterfaceTest::EncodeOneIDRandP (ISVCEncoder* pPtrEnc) {
131 int iResult;
132 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
133 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
134 EXPECT_EQ (sFbi.eFrameType, static_cast<int> (videoFrameTypeIDR));
135
136 pSrcPic->uiTimeStamp += 30;
137 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
138 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
139 }
140
InitializeParamExt()141 void EncoderInterfaceTest::InitializeParamExt() {
142 pParamExt->iPicWidth = 1280;
143 pParamExt->iPicHeight = 720;
144 pParamExt->iTargetBitrate = 50000;
145 pParamExt->iTemporalLayerNum = 3;
146 pParamExt->iSpatialLayerNum = 1;
147 pParamExt->iNumRefFrame = AUTO_REF_PIC_COUNT;
148 pParamExt->sSpatialLayers[0].iVideoHeight = pParamExt->iPicHeight;
149 pParamExt->sSpatialLayers[0].iVideoWidth = pParamExt->iPicWidth;
150 pParamExt->sSpatialLayers[0].iSpatialBitrate = 50000;
151 }
152
TEST_F(EncoderInterfaceTest,EncoderOptionSetTest)153 TEST_F (EncoderInterfaceTest, EncoderOptionSetTest) {
154 int iResult, iValue, iReturn;
155 float fFrameRate, fReturn;
156 int uiTraceLevel = WELS_LOG_QUIET;
157
158 pPtrEnc->SetOption (ENCODER_OPTION_TRACE_LEVEL, &uiTraceLevel);
159
160 InitializeParamExt();
161 iResult = pPtrEnc->InitializeExt (pParamExt);
162 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
163
164 PrepareOneSrcFrame();
165
166 ENCODER_OPTION eOptionId = ENCODER_OPTION_DATAFORMAT;
167 iValue = rand() % 256;
168 iResult = pPtrEnc->SetOption (eOptionId, &iValue);
169
170 if (iValue == 0)
171 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
172 else
173 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
174
175 iResult = pPtrEnc->GetOption (eOptionId, &iReturn);
176 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
177 EXPECT_EQ (iValue, iReturn);
178
179 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
180 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
181 pSrcPic->uiTimeStamp += 30;
182
183 eOptionId = ENCODER_OPTION_IDR_INTERVAL;
184 iValue = rand() % 256 - 5;
185 iResult = pPtrEnc->SetOption (eOptionId, &iValue);
186 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
187
188 iResult = pPtrEnc->GetOption (eOptionId, &iReturn);
189 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
190 if (iValue <= -1)
191 iValue = 0;
192 EXPECT_EQ (iValue, iReturn);
193
194 PrepareOneSrcFrame();
195 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
196 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
197 pSrcPic->uiTimeStamp += 30;
198
199 eOptionId = ENCODER_OPTION_FRAME_RATE;
200 fFrameRate = static_cast<float> (rand() % 100 - 5);
201 iResult = pPtrEnc->SetOption (eOptionId, &fFrameRate);
202
203 if (fFrameRate <= 0)
204 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
205 else {
206 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
207
208 fFrameRate = WELS_CLIP3 (fFrameRate, 1, 60);
209 iResult = pPtrEnc->GetOption (eOptionId, &fReturn);
210 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
211 EXPECT_EQ (fFrameRate, fReturn);
212 }
213 PrepareOneSrcFrame();
214 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
215 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
216 pSrcPic->uiTimeStamp += 30;
217
218 eOptionId = ENCODER_OPTION_BITRATE;
219 SBitrateInfo sInfo, sReturn;
220 sInfo.iBitrate = rand() % 100000 - 100;
221 sInfo.iLayer = SPATIAL_LAYER_0;
222 iResult = pPtrEnc->SetOption (eOptionId, &sInfo);
223 pPtrEnc->GetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, pParamExt);
224 if (sInfo.iBitrate <= 0 || (static_cast<float> (pParamExt->sSpatialLayers[sInfo.iLayer].iSpatialBitrate) <= fFrameRate))
225 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
226 else if (pParamExt->sSpatialLayers[sInfo.iLayer].iSpatialBitrate >
227 pParamExt->sSpatialLayers[sInfo.iLayer].iMaxSpatialBitrate) {
228 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
229 } else {
230 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
231 sReturn.iLayer = SPATIAL_LAYER_0;
232 iResult = pPtrEnc->GetOption (eOptionId, &sReturn);
233 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
234 EXPECT_EQ (WELS_CLIP3 (sInfo.iBitrate, 1, 2147483647), sReturn.iBitrate);
235 }
236 PrepareOneSrcFrame();
237 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
238 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
239 pSrcPic->uiTimeStamp += 30;
240
241 eOptionId = ENCODER_OPTION_MAX_BITRATE;
242 sInfo.iBitrate = rand() % 100000 - 100;
243 sInfo.iLayer = SPATIAL_LAYER_0;
244 iResult = pPtrEnc->SetOption (eOptionId, &sInfo);
245 pPtrEnc->GetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, pParamExt);
246 if (sInfo.iBitrate <= 0 || (static_cast<float> (pParamExt->sSpatialLayers[sInfo.iLayer].iSpatialBitrate) <= fFrameRate))
247 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
248 else if (pParamExt->sSpatialLayers[sInfo.iLayer].iSpatialBitrate >
249 pParamExt->sSpatialLayers[sInfo.iLayer].iMaxSpatialBitrate) {
250 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
251 } else {
252 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
253 sReturn.iLayer = SPATIAL_LAYER_0;
254 iResult = pPtrEnc->GetOption (eOptionId, &sReturn);
255 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
256 EXPECT_EQ (WELS_CLIP3 (sInfo.iBitrate, 1, 2147483647), sReturn.iBitrate);
257 }
258 PrepareOneSrcFrame();
259 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
260 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
261 pSrcPic->uiTimeStamp += 30;
262
263 eOptionId = ENCODER_OPTION_RC_MODE;
264 iValue = (rand() % 4) - 1;
265 iResult = pPtrEnc->SetOption (eOptionId, &iValue);
266 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
267
268 PrepareOneSrcFrame();
269 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
270 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
271 pSrcPic->uiTimeStamp += 30;
272
273 uiTraceLevel = WELS_LOG_ERROR;
274 pPtrEnc->SetOption (ENCODER_OPTION_TRACE_LEVEL, &uiTraceLevel);
275 }
276
277 //TEST_F (EncoderInterfaceTest, TemporalLayerSettingTest) {
278 //
279 // pParamExt->iPicWidth = 1280;
280 // pParamExt->iPicHeight = 720;
281 // m_iWidth = pParamExt->iPicWidth;
282 // m_iHeight = pParamExt->iPicHeight;
283 // pParamExt->iTargetBitrate = 60000;
284 // pParamExt->sSpatialLayers[0].iVideoHeight = pParamExt->iPicHeight;
285 // pParamExt->sSpatialLayers[0].iVideoWidth = pParamExt->iPicWidth;
286 // pParamExt->sSpatialLayers[0].iSpatialBitrate = 50000;
287 // pParamExt->iTemporalLayerNum = 1;
288 // pParamExt->iSpatialLayerNum = 1;
289 // pParamExt->iNumRefFrame = AUTO_REF_PIC_COUNT;
290 //
291 // for (int i = 0; i < 2; i++) {
292 // pParamExt->iUsageType = ((i == 0) ? SCREEN_CONTENT_REAL_TIME : CAMERA_VIDEO_REAL_TIME);
293 // int iResult = pPtrEnc->InitializeExt (pParamExt);
294 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
295 //
296 // PrepareOneSrcFrame();
297 //
298 // iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
299 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
300 // EXPECT_EQ (sFbi.eFrameType, static_cast<int> (videoFrameTypeIDR));
301 //
302 // pSrcPic->uiTimeStamp = 30;
303 // iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
304 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
305 // EXPECT_EQ (sFbi.eFrameType, static_cast<int> (videoFrameTypeP));
306 //
307 // ENCODER_OPTION eOptionId = ENCODER_OPTION_SVC_ENCODE_PARAM_EXT;
308 // iResult = pPtrEnc->GetOption (eOptionId, pOption);
309 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
310 // pOption ->iTemporalLayerNum = 4;
311 //
312 // iResult = pPtrEnc->SetOption (eOptionId, pOption);
313 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
314 //
315 // pSrcPic->uiTimeStamp = 60;
316 // iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
317 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
318 // EXPECT_EQ (sFbi.eFrameType, static_cast<int> (videoFrameTypeIDR));
319 //
320 // pOption ->iTemporalLayerNum = 2;
321 // iResult = pPtrEnc->SetOption (eOptionId, pOption);
322 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
323 // pSrcPic->uiTimeStamp = 90;
324 // iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
325 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
326 // EXPECT_EQ (sFbi.eFrameType, static_cast<int> (videoFrameTypeP));
327 //
328 // pOption ->iTemporalLayerNum = 4;
329 // iResult = pPtrEnc->SetOption (eOptionId, pOption);
330 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
331 // pSrcPic->uiTimeStamp = 120;
332 // iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
333 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
334 // EXPECT_EQ (sFbi.eFrameType, static_cast<int> (videoFrameTypeP));
335 //
336 // //change backgrouddetection and qp
337 // pOption ->bEnableBackgroundDetection = !pOption ->bEnableBackgroundDetection;
338 // iResult = pPtrEnc->SetOption (eOptionId, pOption);
339 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
340 // pSrcPic->uiTimeStamp = 150;
341 // iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
342 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
343 //
344 // pOption ->bEnableAdaptiveQuant = !pOption ->bEnableAdaptiveQuant;
345 // iResult = pPtrEnc->SetOption (eOptionId, pOption);
346 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
347 // pSrcPic->uiTimeStamp = 180;
348 // iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
349 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
350 //
351 // iResult = pPtrEnc->Uninitialize();
352 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
353 // }
354 //
355 // InitializeParamExt();
356 // pParamExt->iUsageType = (rand() % 2) ? SCREEN_CONTENT_REAL_TIME : CAMERA_VIDEO_REAL_TIME;
357 // pParamExt->iRCMode = (rand() % 2) ? RC_BITRATE_MODE : RC_QUALITY_MODE;
358 //
359 // int iResult = pPtrEnc->InitializeExt (pParamExt);
360 // const int kiFrameNumber = TEST_FRAMES;
361 //
362 // m_iWidth = pParamExt->iPicWidth;
363 // m_iHeight = pParamExt->iPicHeight;
364 // m_iPicResSize = m_iWidth * m_iHeight * 3 >> 1;
365 // delete []pYUV;
366 // pYUV = new unsigned char [m_iPicResSize];
367 // ASSERT_TRUE (pYUV != NULL);
368 // PrepareOneSrcFrame();
369 //
370 // ENCODER_OPTION eOptionId = ENCODER_OPTION_SVC_ENCODE_PARAM_EXT;
371 // memcpy (pOption, pParamExt, sizeof (SEncParamExt));
372 //
373 // for (int i = 0; i < kiFrameNumber; i ++) {
374 // if ((i % 7) == 0) {
375 // if (pOption->iTemporalLayerNum < 4) {
376 // pOption->iTemporalLayerNum++;
377 // } else {
378 // pOption->iTemporalLayerNum--;
379 // }
380 // iResult = pPtrEnc->SetOption (eOptionId, pOption);
381 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
382 // pSrcPic->uiTimeStamp += 30;
383 // }
384 //
385 // int iStartX = rand() % (m_iPicResSize >> 1);
386 // int iEndX = (iStartX + (rand() % MEM_VARY_SIZE)) % m_iPicResSize;
387 // for (int j = iStartX; j < iEndX; j++)
388 // pYUV[j] = rand() % 256;
389 //
390 // iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
391 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
392 // pSrcPic->uiTimeStamp += 30;
393 // }
394 //
395 // iResult = pPtrEnc->Uninitialize();
396 // EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
397 //
398 //}
399
TEST_F(EncoderInterfaceTest,MemoryCheckTest)400 TEST_F (EncoderInterfaceTest, MemoryCheckTest) {
401
402 InitializeParamExt();
403 pParamExt->iPicWidth = 1280;
404 pParamExt->iPicHeight = 720;
405
406 int iResult = pPtrEnc->InitializeExt (pParamExt);
407 const int kiFrameNumber = TEST_FRAMES;
408
409 m_iWidth = pParamExt->iPicWidth;
410 m_iHeight = pParamExt->iPicHeight;
411 m_iPicResSize = m_iWidth * m_iHeight * 3 >> 1;
412 delete []pYUV;
413 pYUV = new unsigned char [m_iPicResSize];
414 PrepareOneSrcFrame();
415
416 for (int i = 0; i < kiFrameNumber; i ++) {
417 int iStartX = rand() % (m_iPicResSize >> 1);
418 int iEndX = (iStartX + (rand() % MEM_VARY_SIZE)) % m_iPicResSize;
419 for (int j = iStartX; j < iEndX; j++)
420 pYUV[j] = rand() % 256;
421
422 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
423 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
424 pSrcPic->uiTimeStamp += 30;
425 }
426
427 pParamExt->iPicWidth += (rand() << 1) % IMAGE_VARY_SIZE;
428 pParamExt->iPicHeight += (rand() << 1) % IMAGE_VARY_SIZE;
429 m_iWidth = pParamExt->iPicWidth;
430 m_iHeight = pParamExt->iPicHeight;
431 m_iPicResSize = m_iWidth * m_iHeight * 3 >> 1;
432 delete []pYUV;
433 pYUV = new unsigned char [m_iPicResSize];
434
435 iResult = pPtrEnc->InitializeExt (pParamExt);
436 PrepareOneSrcFrame();
437
438 ENCODER_OPTION eOptionId = ENCODER_OPTION_SVC_ENCODE_PARAM_EXT;
439 memcpy (pOption, pParamExt, sizeof (SEncParamExt));
440 pOption ->iPicWidth = m_iWidth;
441 pOption ->iPicHeight = m_iHeight;
442 iResult = pPtrEnc->SetOption (eOptionId, pOption);
443 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
444
445 for (int i = 0; i < kiFrameNumber; i ++) {
446 int iStartX = rand() % (m_iPicResSize >> 1);
447 int iEndX = (iStartX + (rand() % MEM_VARY_SIZE)) % m_iPicResSize;
448 for (int j = iStartX; j < iEndX; j++)
449 pYUV[j] = rand() % 256;
450
451 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
452 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
453 pSrcPic->uiTimeStamp += 30;
454 }
455
456 pOption ->iLTRRefNum += rand() % 8 + 1;
457 iResult = pPtrEnc->SetOption (eOptionId, pOption);
458 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
459
460 for (int i = 0; i < kiFrameNumber; i ++) {
461 int iStartX = rand() % (m_iPicResSize >> 1);
462 int iEndX = (iStartX + (rand() % MEM_VARY_SIZE)) % m_iPicResSize;
463 for (int j = iStartX; j < iEndX; j++)
464 pYUV[j] = rand() % 256;
465
466 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
467 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
468 pSrcPic->uiTimeStamp += 30;
469 }
470
471 iResult = pPtrEnc->Uninitialize();
472 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
473 }
474
GetValidEncParamBase(SEncParamBase * pEncParamBase)475 void GetValidEncParamBase (SEncParamBase* pEncParamBase) {
476 pEncParamBase->iUsageType = CAMERA_VIDEO_REAL_TIME;
477 pEncParamBase->iPicWidth = 2 + ((rand() % ((MAX_WIDTH >> 1) - 1)) << 1);
478 pEncParamBase->iPicHeight = 2 + ((rand() % ((MAX_HEIGHT >> 1) - 1)) << 1);
479 pEncParamBase->iPicWidth = VALID_SIZE (pEncParamBase->iPicWidth);
480 pEncParamBase->iPicHeight = VALID_SIZE (pEncParamBase->iPicHeight);
481 pEncParamBase->iTargetBitrate = rand() + 1; //!=0
482 // Force a bitrate of at least w*h/50, otherwise we will only get skipped frames
483 pEncParamBase->iTargetBitrate = WELS_CLIP3 (pEncParamBase->iTargetBitrate,
484 pEncParamBase->iPicWidth * pEncParamBase->iPicHeight / 50, 60000000);
485 int32_t iLevelMaxBitrate = WelsCommon::g_ksLevelLimits[LEVEL_NUMBER - 1].uiMaxBR * CpbBrNalFactor;
486 if (pEncParamBase->iTargetBitrate > iLevelMaxBitrate)
487 pEncParamBase->iTargetBitrate = iLevelMaxBitrate;
488 pEncParamBase->iRCMode = RC_BITRATE_MODE; //-1, 0, 1, 2
489 pEncParamBase->fMaxFrameRate = rand() + 0.5f; //!=0
490 }
491
TEST_F(EncoderInterfaceTest,BasicInitializeTest)492 TEST_F (EncoderInterfaceTest, BasicInitializeTest) {
493 SEncParamBase sEncParamBase;
494 GetValidEncParamBase (&sEncParamBase);
495
496 int iResult = pPtrEnc->Initialize (&sEncParamBase);
497 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess)) << "iUsageType = " << sEncParamBase.iUsageType <<
498 ", iPicWidth = " << sEncParamBase.iPicWidth << ", iPicHeight = " << sEncParamBase.iPicHeight << ", iTargetBitrate = " <<
499 sEncParamBase.iTargetBitrate << ", fMaxFrameRate = " << sEncParamBase.fMaxFrameRate;
500
501 PrepareOneSrcFrame();
502
503 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
504 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
505 EXPECT_EQ (sFbi.eFrameType, static_cast<int> (videoFrameTypeIDR));
506
507 iResult = pPtrEnc->Uninitialize();
508 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
509 }
510
TEST_F(EncoderInterfaceTest,BaseParamSettingTest)511 TEST_F (EncoderInterfaceTest, BaseParamSettingTest) {
512 SEncParamBase sEncParamBase;
513 GetValidEncParamBase (&sEncParamBase);
514
515 int iResult = pPtrEnc->Initialize (&sEncParamBase);
516 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess)) << "iUsageType = " << sEncParamBase.iUsageType <<
517 ", iPicWidth = " << sEncParamBase.iPicWidth << ", iPicHeight = " << sEncParamBase.iPicHeight << ", iTargetBitrate = " <<
518 sEncParamBase.iTargetBitrate << ", fMaxFrameRate = " << sEncParamBase.fMaxFrameRate;
519
520 PrepareOneSrcFrame();
521
522 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
523 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
524 EXPECT_EQ (sFbi.eFrameType, static_cast<int> (videoFrameTypeIDR));
525
526 GetValidEncParamBase (&sEncParamBase);
527 iResult = pPtrEnc->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_BASE, &sEncParamBase);
528
529 PrepareOneSrcFrame();
530
531 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
532 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
533
534 iResult = pPtrEnc->Uninitialize();
535 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
536 }
537
TEST_F(EncoderInterfaceTest,BasicInitializeTestFalse)538 TEST_F (EncoderInterfaceTest, BasicInitializeTestFalse) {
539 int iResult;
540 SEncParamBase sEncParamBase;
541 int uiTraceLevel = WELS_LOG_QUIET;
542
543 pPtrEnc->SetOption (ENCODER_OPTION_TRACE_LEVEL, &uiTraceLevel);
544 //iUsageType
545 GetValidEncParamBase (&sEncParamBase);
546 sEncParamBase.iUsageType = static_cast<EUsageType> (2);
547 iResult = pPtrEnc->Initialize (&sEncParamBase);
548 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
549
550 //iPicWidth
551 GetValidEncParamBase (&sEncParamBase);
552 sEncParamBase.iPicWidth = 0;
553 iResult = pPtrEnc->Initialize (&sEncParamBase);
554 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
555
556 GetValidEncParamBase (&sEncParamBase);
557 sEncParamBase.iPicWidth = -1;
558 iResult = pPtrEnc->Initialize (&sEncParamBase);
559 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
560
561 //TODO: add checking max in interface and then enable this checking
562 //GetValidEncParamBase(&sEncParamBase);
563 //sEncParamBase.iPicWidth = rand()+(MAX_WIDTH+1);
564 //iResult = pPtrEnc->Initialize (&sEncParamBase);
565 //EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
566
567 //iPicHeight
568 GetValidEncParamBase (&sEncParamBase);
569 sEncParamBase.iPicHeight = 0;
570 iResult = pPtrEnc->Initialize (&sEncParamBase);
571 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
572
573 GetValidEncParamBase (&sEncParamBase);
574 sEncParamBase.iPicHeight = -1;
575 iResult = pPtrEnc->Initialize (&sEncParamBase);
576 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
577
578 //iPicWidth * iPicHeight <= 36864 * 16 * 16, from Level 5.2 constraint
579 //Initialize test: FALSE
580 GetValidEncParamBase (&sEncParamBase);
581 sEncParamBase.iPicWidth = 5000;
582 sEncParamBase.iPicHeight = 5000;
583 iResult = pPtrEnc->Initialize (&sEncParamBase);
584 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
585 //Initialize test: TRUE, with SetOption test following
586 GetValidEncParamBase (&sEncParamBase);
587 sEncParamBase.iPicWidth = 36864;
588 sEncParamBase.iPicHeight = 256;
589 iResult = pPtrEnc->Initialize (&sEncParamBase);
590 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
591 sEncParamBase.iPicWidth = 256;
592 sEncParamBase.iPicHeight = 36864;
593 iResult = pPtrEnc->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_BASE, &sEncParamBase);
594 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
595 sEncParamBase.iPicWidth = 5000;
596 sEncParamBase.iPicHeight = 5000;
597 iResult = pPtrEnc->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_BASE, &sEncParamBase);
598 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
599 pPtrEnc->Uninitialize();
600
601 //iTargetBitrate
602 GetValidEncParamBase (&sEncParamBase);
603 sEncParamBase.iTargetBitrate = 0;
604 iResult = pPtrEnc->Initialize (&sEncParamBase);
605 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
606 GetValidEncParamBase (&sEncParamBase);
607 sEncParamBase.iTargetBitrate = -1;
608 iResult = pPtrEnc->Initialize (&sEncParamBase);
609 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
610
611 uiTraceLevel = WELS_LOG_ERROR;
612 pPtrEnc->SetOption (ENCODER_OPTION_TRACE_LEVEL, &uiTraceLevel);
613 }
614
TEST_F(EncoderInterfaceTest,BasicInitializeTestAutoAdjustment)615 TEST_F (EncoderInterfaceTest, BasicInitializeTestAutoAdjustment) {
616 SEncParamBase sEncParamBase;
617
618 // large fMaxFrameRate
619 GetValidEncParamBase (&sEncParamBase);
620 sEncParamBase.fMaxFrameRate = 50000;
621 EncodeOneFrame (&sEncParamBase);
622 EXPECT_LE (sEncParamBase.fMaxFrameRate, 60.0);
623 EXPECT_GE (sEncParamBase.fMaxFrameRate, 1.0);
624
625 // fMaxFrameRate = 0
626 GetValidEncParamBase (&sEncParamBase);
627 sEncParamBase.fMaxFrameRate = 0;
628 EncodeOneFrame (&sEncParamBase);
629 EXPECT_LE (sEncParamBase.fMaxFrameRate, 60.0);
630 EXPECT_GE (sEncParamBase.fMaxFrameRate, 1.0);
631
632 // fMaxFrameRate = -1
633 GetValidEncParamBase (&sEncParamBase);
634 sEncParamBase.fMaxFrameRate = -1;
635 EncodeOneFrame (&sEncParamBase);
636 EXPECT_LE (sEncParamBase.fMaxFrameRate, 60.0);
637 EXPECT_GE (sEncParamBase.fMaxFrameRate, 1.0);
638 }
639
TEST_F(EncoderInterfaceTest,ForceIntraFrameSimulCastAVC)640 TEST_F (EncoderInterfaceTest, ForceIntraFrameSimulCastAVC) {
641 SEncParamExt sEncParamExt;
642 pPtrEnc->GetDefaultParams (&sEncParamExt);
643 sEncParamExt.iUsageType = CAMERA_VIDEO_REAL_TIME;
644 int iSpatialLayerNum = rand() % MAX_SPATIAL_LAYER_NUM;
645 sEncParamExt.iSpatialLayerNum = WELS_CLIP3 (iSpatialLayerNum, 1, MAX_SPATIAL_LAYER_NUM);
646
647
648 sEncParamExt.iPicWidth = 1280;
649 sEncParamExt.iPicHeight = 720;
650 sEncParamExt.iTargetBitrate = 0; //!=0
651 sEncParamExt.iRCMode = RC_BITRATE_MODE; //-1, 0, 1, 2
652 sEncParamExt.bEnableFrameSkip = false;
653 sEncParamExt.fMaxFrameRate = 30; //!=0
654 sEncParamExt.bSimulcastAVC = 1;
655
656 for (int iNum = sEncParamExt.iSpatialLayerNum - 1; iNum >= 0 ; iNum--) {
657 int iScale = 1 << ((sEncParamExt.iSpatialLayerNum - 1) - iNum);
658 sEncParamExt.sSpatialLayers[iNum].iVideoWidth = sEncParamExt.iPicWidth / iScale;
659 sEncParamExt.sSpatialLayers[iNum].iVideoHeight = sEncParamExt.iPicHeight / iScale;
660 sEncParamExt.sSpatialLayers[iNum].iSpatialBitrate = (sEncParamExt.sSpatialLayers[iNum].iVideoWidth *
661 sEncParamExt.sSpatialLayers[iNum].iVideoHeight) / 3;
662 sEncParamExt.iTargetBitrate += sEncParamExt.sSpatialLayers[iNum].iSpatialBitrate;
663 }
664 // int uiTraceLevel = WELS_LOG_INFO;
665 // pPtrEnc->SetOption (ENCODER_OPTION_TRACE_LEVEL, &uiTraceLevel);
666 int iResult = pPtrEnc->InitializeExt (&sEncParamExt);
667 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess)) << "iUsageType = " << sEncParamExt.iUsageType <<
668 ", iPicWidth = " << sEncParamExt.iPicWidth << ", iPicHeight = " << sEncParamExt.iPicHeight << ", iTargetBitrate = " <<
669 sEncParamExt.iTargetBitrate << ", fMaxFrameRate = " << sEncParamExt.fMaxFrameRate;
670
671 int kiFrameNumber = rand() % 100;
672 if (kiFrameNumber < 20)
673 kiFrameNumber = 20;
674 for (int i = 0; i < kiFrameNumber; i ++) {
675 PrepareOneSrcFrame();
676 bool bForceIdr = (i == (kiFrameNumber / 2));
677 int iLayerNum = rand() % MAX_SPATIAL_LAYER_NUM;
678 iLayerNum = WELS_CLIP3 (iSpatialLayerNum, 0, sEncParamExt.iSpatialLayerNum - 1);
679 if (bForceIdr) {
680 pPtrEnc->ForceIntraFrame (true, iLayerNum);
681 }
682
683 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
684 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
685 if (bForceIdr) {
686 for (int i = 0; i < sFbi.iLayerNum; ++i) {
687 if (sFbi.sLayerInfo[i].uiSpatialId == iLayerNum) {
688 EXPECT_EQ (sFbi.sLayerInfo[i].eFrameType, static_cast<int> (videoFrameTypeIDR));
689 }
690 }
691 }
692 }
693
694 pPtrEnc->Uninitialize();
695 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
696 }
697
698
TEST_F(EncoderInterfaceTest,ForceIntraFrame)699 TEST_F (EncoderInterfaceTest, ForceIntraFrame) {
700 SEncParamBase sEncParamBase;
701 GetValidEncParamBase (&sEncParamBase);
702
703 int iResult = pPtrEnc->Initialize (&sEncParamBase);
704 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess)) << "iUsageType = " << sEncParamBase.iUsageType <<
705 ", iPicWidth = " << sEncParamBase.iPicWidth << ", iPicHeight = " << sEncParamBase.iPicHeight << ", iTargetBitrate = " <<
706 sEncParamBase.iTargetBitrate << ", fMaxFrameRate = " << sEncParamBase.fMaxFrameRate;
707
708 PrepareOneSrcFrame();
709
710 bool bIDR = true;
711 pPtrEnc->ForceIntraFrame (bIDR);
712 EncodeOneIDRandP (pPtrEnc);
713
714 //call next frame to be IDR
715 pPtrEnc->ForceIntraFrame (bIDR);
716 int iCount = 0;
717 do {
718 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
719 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
720 pSrcPic->uiTimeStamp += 30;
721 } while ((sFbi.eFrameType == static_cast<int> (videoFrameTypeSkip)) && (iCount ++ < 100));
722 EXPECT_EQ (sFbi.eFrameType, static_cast<int> (videoFrameTypeIDR));
723
724 pPtrEnc->Uninitialize();
725 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
726 }
727
TEST_F(EncoderInterfaceTest,ForceIntraFrameWithTemporal)728 TEST_F (EncoderInterfaceTest, ForceIntraFrameWithTemporal) {
729 SEncParamExt sEncParamExt;
730 pPtrEnc->GetDefaultParams (&sEncParamExt);
731 sEncParamExt.iUsageType = CAMERA_VIDEO_REAL_TIME;
732 sEncParamExt.iPicWidth = MB_SIZE + abs ((rand() / 2 * 2) % (MAX_WIDTH - MB_SIZE));
733 sEncParamExt.iPicHeight = MB_SIZE + abs ((rand() / 2 * 2) % (MAX_HEIGHT - MB_SIZE));
734 sEncParamExt.iTargetBitrate = rand() + 1; //!=0
735 // Force a bitrate of at least w*h/50, otherwise we will only get skipped frames
736 sEncParamExt.iTargetBitrate = WELS_CLIP3 (sEncParamExt.iTargetBitrate,
737 sEncParamExt.iPicWidth * sEncParamExt.iPicHeight / 50, 60000000);
738 int32_t iLevelMaxBitrate = WelsCommon::g_ksLevelLimits[LEVEL_NUMBER - 1].uiMaxBR * CpbBrNalFactor;
739 if (sEncParamExt.iTargetBitrate > iLevelMaxBitrate)
740 sEncParamExt.iTargetBitrate = iLevelMaxBitrate;
741 sEncParamExt.iRCMode = RC_BITRATE_MODE; //-1, 0, 1, 2
742 sEncParamExt.fMaxFrameRate = rand() + 0.5f; //!=0
743 sEncParamExt.sSpatialLayers[0].iVideoWidth = sEncParamExt.iPicWidth;
744 sEncParamExt.sSpatialLayers[0].iVideoHeight = sEncParamExt.iPicHeight;
745 sEncParamExt.sSpatialLayers[0].iSpatialBitrate = sEncParamExt.iTargetBitrate;
746 int iTargetTemporalLayerNum = rand() % MAX_TEMPORAL_LAYER_NUM;
747 sEncParamExt.iTemporalLayerNum = (iTargetTemporalLayerNum > 2) ? iTargetTemporalLayerNum : 2;
748
749 int iResult = pPtrEnc->InitializeExt (&sEncParamExt);
750 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess)) << "iUsageType = " << sEncParamExt.iUsageType <<
751 ", iPicWidth = " << sEncParamExt.iPicWidth << ", iPicHeight = " << sEncParamExt.iPicHeight << ", iTargetBitrate = " <<
752 sEncParamExt.iTargetBitrate << ", fMaxFrameRate = " << sEncParamExt.fMaxFrameRate;
753
754 PrepareOneSrcFrame();
755
756 bool bIDR = true;
757 EncodeOneIDRandP (pPtrEnc);
758
759 //call next frame to be IDR
760 pPtrEnc->ForceIntraFrame (bIDR);
761 int iCount = 0;
762 do {
763 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
764 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
765 pSrcPic->uiTimeStamp += 30;
766 } while ((sFbi.eFrameType == static_cast<int> (videoFrameTypeSkip)) && (iCount ++ < 100));
767 EXPECT_EQ (sFbi.eFrameType, static_cast<int> (videoFrameTypeIDR));
768
769 pPtrEnc->Uninitialize();
770 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
771 }
772
TEST_F(EncoderInterfaceTest,EncodeParameterSets)773 TEST_F (EncoderInterfaceTest, EncodeParameterSets) {
774 SEncParamBase sEncParamBase;
775 GetValidEncParamBase (&sEncParamBase);
776
777 int iResult = pPtrEnc->Initialize (&sEncParamBase);
778 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess)) << "iUsageType = " << sEncParamBase.iUsageType <<
779 ", iPicWidth = " << sEncParamBase.iPicWidth << ", iPicHeight = " << sEncParamBase.iPicHeight << ", iTargetBitrate = " <<
780 sEncParamBase.iTargetBitrate << ", fMaxFrameRate = " << sEncParamBase.fMaxFrameRate;
781 PrepareOneSrcFrame();
782 EncodeOneIDRandP (pPtrEnc);
783
784 //try EncodeParameterSets
785 pPtrEnc->EncodeParameterSets (&sFbi);
786 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
787 EXPECT_EQ (sFbi.eFrameType, static_cast<int> (videoFrameTypeInvalid));
788
789 //check the result
790 int iNalType = 0;
791 SLayerBSInfo* pLayerBsInfo;
792 for (int i = 0; i < sFbi.iLayerNum; i++) {
793 pLayerBsInfo = & (sFbi.sLayerInfo[i]);
794 EXPECT_EQ (pLayerBsInfo->uiLayerType , static_cast<int> (NON_VIDEO_CODING_LAYER));
795
796 iNalType = GET_NAL_TYPE (pLayerBsInfo->pBsBuf);
797 EXPECT_EQ (true, IS_PARASET (iNalType));
798 for (int j = 0; j < (pLayerBsInfo->iNalCount - 1); j++) {
799 iNalType = GET_NAL_TYPE (pLayerBsInfo->pBsBuf + pLayerBsInfo->pNalLengthInByte[j]);
800 EXPECT_EQ (true, IS_PARASET (iNalType));
801 }
802 }
803
804 //try another P to make sure no impact on succeeding frames
805 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
806 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
807 EXPECT_NE (sFbi.eFrameType, static_cast<int> (videoFrameTypeIDR));
808
809 iResult = pPtrEnc->Uninitialize();
810 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
811 }
812
TEST_F(EncoderInterfaceTest,BasicReturnTypeTest)813 TEST_F (EncoderInterfaceTest, BasicReturnTypeTest) {
814 //TODO
815 }
816
ChangeResolutionAndCheckStatistics(const SEncParamBase & sEncParamBase,SEncoderStatistics * pEncoderStatistics)817 void EncoderInterfaceTest::ChangeResolutionAndCheckStatistics (const SEncParamBase& sEncParamBase,
818 SEncoderStatistics* pEncoderStatistics) {
819 unsigned int uiExistingFrameCount = pEncoderStatistics->uiInputFrameCount;
820 unsigned int uiExistingIDR = pEncoderStatistics->uiIDRSentNum;
821 unsigned int uiExistingResolutionChange = pEncoderStatistics->uiResolutionChangeTimes;
822
823 // 1, get the existing param
824 int iResult = pPtrEnc->GetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, pParamExt);
825 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
826
827 // 2, change setting
828 unsigned int uiKnownResolutionChangeTimes = uiExistingResolutionChange;
829 bool bCheckIDR = false;
830 if (pParamExt->iPicWidth != sEncParamBase.iPicWidth || pParamExt->iPicHeight != sEncParamBase.iPicHeight) {
831 uiKnownResolutionChangeTimes += 1;
832 bCheckIDR = true;
833 }
834 pParamExt->iPicWidth = pParamExt->sSpatialLayers[0].iVideoWidth = sEncParamBase.iPicWidth;
835 pParamExt->iPicHeight = pParamExt->sSpatialLayers[0].iVideoHeight = sEncParamBase.iPicHeight;
836 pPtrEnc->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, pParamExt);
837 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
838
839 // 3, code one frame
840 PrepareOneSrcFrame();
841 pSrcPic->uiTimeStamp = 30 * pEncoderStatistics->uiInputFrameCount;
842 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
843 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
844 iResult = pPtrEnc->GetOption (ENCODER_OPTION_GET_STATISTICS, pEncoderStatistics);
845 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
846
847 EXPECT_EQ (pEncoderStatistics->uiInputFrameCount, uiExistingFrameCount + 1);
848 EXPECT_EQ (pEncoderStatistics->uiResolutionChangeTimes, uiKnownResolutionChangeTimes);
849 if (bCheckIDR) {
850 EXPECT_EQ (pEncoderStatistics->uiIDRSentNum, uiExistingIDR + 1);
851 }
852
853 EXPECT_EQ (pEncoderStatistics->uiWidth, static_cast<unsigned int> (sEncParamBase.iPicWidth));
854 EXPECT_EQ (pEncoderStatistics->uiHeight, static_cast<unsigned int> (sEncParamBase.iPicHeight));
855 }
856
857
TEST_F(EncoderInterfaceTest,GetStatistics)858 TEST_F (EncoderInterfaceTest, GetStatistics) {
859 SEncParamBase sEncParamBase;
860 GetValidEncParamBase (&sEncParamBase);
861
862 int iResult = pPtrEnc->Initialize (&sEncParamBase);
863 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess)) << "iUsageType = " << sEncParamBase.iUsageType <<
864 ", iPicWidth = " << sEncParamBase.iPicWidth << ", iPicHeight = " << sEncParamBase.iPicHeight << ", iTargetBitrate = " <<
865 sEncParamBase.iTargetBitrate << ", fMaxFrameRate = " << sEncParamBase.fMaxFrameRate;
866
867 PrepareOneSrcFrame();
868 EncodeOneIDRandP (pPtrEnc);
869
870 SEncoderStatistics sEncoderStatistics;
871 iResult = pPtrEnc->GetOption (ENCODER_OPTION_GET_STATISTICS, &sEncoderStatistics);
872 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
873 EXPECT_EQ (sEncoderStatistics.uiInputFrameCount, static_cast<unsigned int> (2));
874 EXPECT_EQ (sEncoderStatistics.uiIDRSentNum, static_cast<unsigned int> (1));
875 EXPECT_EQ (sEncoderStatistics.uiResolutionChangeTimes, static_cast<unsigned int> (0));
876
877 EXPECT_EQ (sEncoderStatistics.uiWidth, static_cast<unsigned int> (sEncParamBase.iPicWidth));
878 EXPECT_EQ (sEncoderStatistics.uiHeight, static_cast<unsigned int> (sEncParamBase.iPicHeight));
879
880 // try param change
881 GetValidEncParamBase (&sEncParamBase);
882 ChangeResolutionAndCheckStatistics (sEncParamBase, &sEncoderStatistics);
883
884 GetValidEncParamBase (&sEncParamBase);
885 sEncParamBase.iPicWidth = (sEncParamBase.iPicWidth % 16) + 1; //try 1~16
886 sEncParamBase.iPicHeight = (sEncParamBase.iPicHeight % 16) + 1; //try 1~16
887 ChangeResolutionAndCheckStatistics (sEncParamBase, &sEncoderStatistics);
888
889 // try timestamp and frame rate
890 pSrcPic->uiTimeStamp = 1000;
891 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
892 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
893 iResult = pPtrEnc->GetOption (ENCODER_OPTION_GET_STATISTICS, &sEncoderStatistics);
894 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
895 EXPECT_EQ (static_cast<unsigned int> (sEncoderStatistics.fAverageFrameRate), sEncoderStatistics.uiInputFrameCount);
896
897 // 4, change log interval
898 int32_t iInterval = 0;
899 iResult = pPtrEnc->GetOption (ENCODER_OPTION_STATISTICS_LOG_INTERVAL, &iInterval);
900 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
901 EXPECT_EQ (iInterval, 5000);
902
903 int32_t iInterval2 = 2000;
904 iResult = pPtrEnc->SetOption (ENCODER_OPTION_STATISTICS_LOG_INTERVAL, &iInterval2);
905 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
906 iResult = pPtrEnc->GetOption (ENCODER_OPTION_STATISTICS_LOG_INTERVAL, &iInterval);
907 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
908 EXPECT_EQ (iInterval, iInterval2);
909
910 iInterval2 = 0;
911 iResult = pPtrEnc->SetOption (ENCODER_OPTION_STATISTICS_LOG_INTERVAL, &iInterval2);
912 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
913 iResult = pPtrEnc->GetOption (ENCODER_OPTION_STATISTICS_LOG_INTERVAL, &iInterval);
914 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
915 EXPECT_EQ (iInterval, iInterval2);
916
917 // finish
918 pPtrEnc->Uninitialize();
919 }
920
TEST_F(EncoderInterfaceTest,FrameSizeCheck)921 TEST_F (EncoderInterfaceTest, FrameSizeCheck) {
922 SEncParamBase sEncParamBase;
923 GetValidEncParamBase (&sEncParamBase);
924
925 int iResult = pPtrEnc->Initialize (&sEncParamBase);
926 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess)) << "iUsageType = " << sEncParamBase.iUsageType <<
927 ", iPicWidth = " << sEncParamBase.iPicWidth << ", iPicHeight = " << sEncParamBase.iPicHeight << ", iTargetBitrate = " <<
928 sEncParamBase.iTargetBitrate << ", fMaxFrameRate = " << sEncParamBase.fMaxFrameRate;
929
930 PrepareOneSrcFrame();
931 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
932
933 int length = 0;
934 for (int i = 0; i < sFbi.iLayerNum; ++i) {
935 for (int j = 0; j < sFbi.sLayerInfo[i].iNalCount; ++j) {
936 length += sFbi.sLayerInfo[i].pNalLengthInByte[j];
937 }
938 }
939 EXPECT_EQ (length, sFbi.iFrameSizeInBytes);
940
941 // finish
942 pPtrEnc->Uninitialize();
943 }
944
TEST_F(EncoderInterfaceTest,SkipFrameCheck)945 TEST_F (EncoderInterfaceTest, SkipFrameCheck) {
946 SEncParamExt sEncParamExt;
947 int iResult = pPtrEnc->GetDefaultParams (&sEncParamExt);
948 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
949
950 //actual encode param: iUsageType = 0, spatial_layer_num = 1, temporal_layer_num = 3, frame_rate = 28.248587, target_bitrate = 573000, denoise =0, background_detection = 1, adaptive_quant = 1, enable_crop_pic = 1, scenechange_detection = 0, enable_long_term_reference = 0, ltr_mark_period = 30, ltr_ref_num = 0, enable_multiple_slice = 1, padding = 0, rc_mode = 1, enable_frame_skip = 1, max_bitrate = 573000, max_nalu_size = 0s
951 //actual encode param: spatial 0: width=360, height=640, frame_rate=28.248587, spatial_bitrate=573000, max_layer_bitrate =895839855, max_nalu_size=0, slice_mode=1,this=0x7c62ee48
952 sEncParamExt.iUsageType = CAMERA_VIDEO_REAL_TIME;
953 sEncParamExt.iPicWidth = 360;
954 sEncParamExt.iPicHeight = 640;
955 sEncParamExt.iTargetBitrate = 573000;
956 sEncParamExt.iRCMode = RC_BITRATE_MODE;
957 sEncParamExt.fMaxFrameRate = 28.248587f;
958
959 sEncParamExt.iTemporalLayerNum = 3;
960 sEncParamExt.iSpatialLayerNum = 1;
961 sEncParamExt.bEnableLongTermReference = 0;
962 sEncParamExt.bEnableSceneChangeDetect = 0;
963 sEncParamExt.bEnableFrameSkip = 1;
964 sEncParamExt.iMaxBitrate = 895839855;
965 sEncParamExt.uiMaxNalSize = 0;
966
967 sEncParamExt.sSpatialLayers[0].uiLevelIdc = LEVEL_5_0;
968 sEncParamExt.sSpatialLayers[0].iVideoWidth = 360;
969 sEncParamExt.sSpatialLayers[0].iVideoHeight = 640;
970 sEncParamExt.sSpatialLayers[0].fFrameRate = 28.248587f;
971 sEncParamExt.sSpatialLayers[0].iSpatialBitrate = 573000;
972 sEncParamExt.sSpatialLayers[0].iMaxSpatialBitrate = 895839855;
973 sEncParamExt.sSpatialLayers[0].sSliceArgument.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
974
975 pParamExt->iPicWidth = sEncParamExt.sSpatialLayers[0].iVideoWidth;
976 pParamExt->iPicHeight = sEncParamExt.sSpatialLayers[0].iVideoHeight;
977
978 iResult = pPtrEnc->InitializeExt (&sEncParamExt);
979 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess)) << "iUsageType = " << sEncParamExt.iUsageType <<
980 ", iPicWidth = " << sEncParamExt.iPicWidth << ", iPicHeight = " << sEncParamExt.iPicHeight << ", iTargetBitrate = " <<
981 sEncParamExt.iTargetBitrate << ", fMaxFrameRate = " << sEncParamExt.fMaxFrameRate;
982
983 int iInterval = 300;
984 iResult = pPtrEnc->SetOption (ENCODER_OPTION_STATISTICS_LOG_INTERVAL, &iInterval);
985 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
986
987 SEncoderStatistics sEncoderStatistics;
988 for (int i = 0; i < 50; i++) {
989 PrepareOneSrcFrame();
990 pSrcPic->uiTimeStamp = i * 33;
991 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
992
993 if (i == 25) {
994 sEncParamExt.fMaxFrameRate = 28;
995 sEncParamExt.sSpatialLayers[0].fFrameRate = 28;
996 sEncParamExt.sSpatialLayers[0].iSpatialBitrate = 500000;
997 iResult = pPtrEnc->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, &sEncParamExt);
998 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
999 }
1000
1001 }
1002 iResult = pPtrEnc->GetOption (ENCODER_OPTION_GET_STATISTICS, &sEncoderStatistics);
1003 EXPECT_TRUE ((sEncoderStatistics.uiInputFrameCount - sEncoderStatistics.uiSkippedFrameCount) > 2)
1004 << "uiInputFrameCount = " << sEncoderStatistics.uiInputFrameCount << ", uiSkippedFrameCount = " <<
1005 sEncoderStatistics.uiSkippedFrameCount;
1006 // finish
1007 pPtrEnc->Uninitialize();
1008 }
1009
TEST_F(EncoderInterfaceTest,DiffResolutionCheck)1010 TEST_F (EncoderInterfaceTest, DiffResolutionCheck) {
1011 SEncParamExt sEncParamExt;
1012 int iResult = pPtrEnc->GetDefaultParams (&sEncParamExt);
1013 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
1014
1015 //actual encode param: iUsageType = 0, spatial_layer_num = 1, temporal_layer_num = 3, frame_rate = 28.248587, target_bitrate = 573000, denoise =0, background_detection = 1, adaptive_quant = 1, enable_crop_pic = 1, scenechange_detection = 0, enable_long_term_reference = 0, ltr_mark_period = 30, ltr_ref_num = 0, enable_multiple_slice = 1, padding = 0, rc_mode = 1, enable_frame_skip = 1, max_bitrate = 573000, max_nalu_size = 0s
1016 //actual encode param: spatial 0: width=360, height=640, frame_rate=28.248587, spatial_bitrate=573000, max_layer_bitrate =895839855, max_nalu_size=0, slice_mode=1,this=0x7c62ee48
1017 sEncParamExt.iUsageType = CAMERA_VIDEO_REAL_TIME;
1018 sEncParamExt.iPicWidth = 360;
1019 sEncParamExt.iPicHeight = 640;
1020 sEncParamExt.iTargetBitrate = 1000000;
1021 sEncParamExt.iRCMode = RC_BITRATE_MODE;
1022 sEncParamExt.fMaxFrameRate = 24;
1023
1024 sEncParamExt.iTemporalLayerNum = 3;
1025 sEncParamExt.iSpatialLayerNum = 3;
1026 sEncParamExt.bEnableLongTermReference = 0;
1027 sEncParamExt.bEnableSceneChangeDetect = 0;
1028 sEncParamExt.bEnableFrameSkip = 1;
1029 sEncParamExt.uiMaxNalSize = 0;
1030
1031 sEncParamExt.sSpatialLayers[0].uiLevelIdc = LEVEL_UNKNOWN;
1032 sEncParamExt.sSpatialLayers[0].iVideoWidth = 90;
1033 sEncParamExt.sSpatialLayers[0].iVideoHeight = 160;
1034 sEncParamExt.sSpatialLayers[0].fFrameRate = 6;
1035 sEncParamExt.sSpatialLayers[0].iSpatialBitrate = 80000;
1036 sEncParamExt.sSpatialLayers[0].sSliceArgument.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
1037
1038 sEncParamExt.sSpatialLayers[1].uiLevelIdc = LEVEL_UNKNOWN;
1039 sEncParamExt.sSpatialLayers[1].iVideoWidth = 180;
1040 sEncParamExt.sSpatialLayers[1].iVideoHeight = 320;
1041 sEncParamExt.sSpatialLayers[1].fFrameRate = 12;
1042 sEncParamExt.sSpatialLayers[1].iSpatialBitrate = 200000;
1043 sEncParamExt.sSpatialLayers[1].sSliceArgument.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
1044
1045 sEncParamExt.sSpatialLayers[2].uiLevelIdc = LEVEL_UNKNOWN;
1046 sEncParamExt.sSpatialLayers[2].iVideoWidth = 360;
1047 sEncParamExt.sSpatialLayers[2].iVideoHeight = 640;
1048 sEncParamExt.sSpatialLayers[2].fFrameRate = 24;
1049 sEncParamExt.sSpatialLayers[2].iSpatialBitrate = 600000;
1050 sEncParamExt.sSpatialLayers[2].sSliceArgument.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
1051
1052 pParamExt->iPicWidth = sEncParamExt.iPicWidth;
1053 pParamExt->iPicHeight = sEncParamExt.iPicWidth;
1054
1055 iResult = pPtrEnc->InitializeExt (&sEncParamExt);
1056 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess)) << "iUsageType = " << sEncParamExt.iUsageType <<
1057 ", iPicWidth = " << sEncParamExt.iPicWidth << ", iPicHeight = " << sEncParamExt.iPicHeight << ", iTargetBitrate = " <<
1058 sEncParamExt.iTargetBitrate << ", fMaxFrameRate = " << sEncParamExt.fMaxFrameRate;
1059
1060 PrepareOneSrcFrame();
1061 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
1062 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
1063 pSrcPic->uiTimeStamp += 30;
1064
1065 //correct setting
1066 sEncParamExt.iSpatialLayerNum = 2;
1067 sEncParamExt.sSpatialLayers[1].uiLevelIdc = LEVEL_UNKNOWN;
1068 sEncParamExt.sSpatialLayers[1].iVideoWidth = 360;
1069 sEncParamExt.sSpatialLayers[1].iVideoHeight = 640;
1070 sEncParamExt.sSpatialLayers[1].fFrameRate = 24;
1071 sEncParamExt.sSpatialLayers[1].iSpatialBitrate = 600000;
1072 iResult = pPtrEnc->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, &sEncParamExt);
1073 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
1074
1075 PrepareOneSrcFrame();
1076 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
1077 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
1078 pSrcPic->uiTimeStamp += 30;
1079
1080 //incorrect setting
1081 int uiTraceLevel = WELS_LOG_QUIET;
1082 pPtrEnc->SetOption (ENCODER_OPTION_TRACE_LEVEL, &uiTraceLevel);
1083
1084 sEncParamExt.sSpatialLayers[1].iVideoWidth = 90;
1085 sEncParamExt.sSpatialLayers[1].iVideoHeight = 160;
1086 sEncParamExt.sSpatialLayers[1].fFrameRate = 6;
1087 sEncParamExt.sSpatialLayers[1].iSpatialBitrate = 80000;
1088
1089 sEncParamExt.sSpatialLayers[0].iVideoWidth = 360;
1090 sEncParamExt.sSpatialLayers[0].iVideoHeight = 640;
1091 sEncParamExt.sSpatialLayers[0].fFrameRate = 24;
1092 sEncParamExt.sSpatialLayers[0].iSpatialBitrate = 600000;
1093 iResult = pPtrEnc->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, &sEncParamExt);
1094 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
1095
1096 //incorrect setting
1097 sEncParamExt.iSpatialLayerNum = 3;
1098 sEncParamExt.sSpatialLayers[1].iVideoWidth = 90;
1099 sEncParamExt.sSpatialLayers[1].iVideoHeight = 160;
1100 sEncParamExt.sSpatialLayers[1].fFrameRate = 6;
1101 sEncParamExt.sSpatialLayers[1].iSpatialBitrate = 80000;
1102
1103 sEncParamExt.sSpatialLayers[0].iVideoWidth = 180;
1104 sEncParamExt.sSpatialLayers[0].iVideoHeight = 320;
1105 sEncParamExt.sSpatialLayers[0].fFrameRate = 12;
1106 sEncParamExt.sSpatialLayers[0].iSpatialBitrate = 200000;
1107
1108 sEncParamExt.sSpatialLayers[2].iVideoWidth = 360;
1109 sEncParamExt.sSpatialLayers[2].iVideoHeight = 640;
1110 sEncParamExt.sSpatialLayers[2].fFrameRate = 24;
1111 sEncParamExt.sSpatialLayers[2].iSpatialBitrate = 600000;
1112 iResult = pPtrEnc->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, &sEncParamExt);
1113 EXPECT_EQ (iResult, static_cast<int> (cmInitParaError));
1114
1115 // finish
1116 pPtrEnc->Uninitialize();
1117 }
1118
TEST_F(EncoderInterfaceTest,NalSizeChecking)1119 TEST_F (EncoderInterfaceTest, NalSizeChecking) {
1120 // int uiTraceLevel = WELS_LOG_DETAIL;
1121 // pPtrEnc->SetOption (ENCODER_OPTION_TRACE_LEVEL, &uiTraceLevel);
1122
1123 pParamExt->iPicWidth = 1280;
1124 pParamExt->iPicHeight = 720;
1125 pParamExt->iPicWidth += (rand() << 1) % IMAGE_VARY_SIZE;
1126 pParamExt->iPicHeight += (rand() << 1) % IMAGE_VARY_SIZE;
1127 pParamExt->fMaxFrameRate = 30;
1128 pParamExt->iTemporalLayerNum = rand() % 3;
1129 pParamExt->iSpatialLayerNum = rand() % 4;
1130 pParamExt->iNumRefFrame = AUTO_REF_PIC_COUNT;
1131 pParamExt->iSpatialLayerNum = WELS_CLIP3 (pParamExt->iSpatialLayerNum, 1, 4);
1132
1133 pParamExt->iMultipleThreadIdc = 1;//multi-thread can't control size. will be fixed.
1134 pParamExt->iEntropyCodingModeFlag = rand() % 2;
1135 int iMaxNalSize = rand() % 5000;
1136 iMaxNalSize = WELS_CLIP3 (iMaxNalSize, 1000, 5000);
1137 pParamExt->uiMaxNalSize = iMaxNalSize;
1138 for (int i = 0; i < pParamExt->iSpatialLayerNum; i++) {
1139 pParamExt->sSpatialLayers[i].sSliceArgument.uiSliceMode = SM_SIZELIMITED_SLICE;
1140 pParamExt->sSpatialLayers[i].sSliceArgument.uiSliceSizeConstraint = iMaxNalSize;
1141 pParamExt->sSpatialLayers[i].iVideoHeight = pParamExt->iPicHeight;
1142 pParamExt->sSpatialLayers[i].iVideoWidth = pParamExt->iPicWidth;
1143 int bitrate = rand() % 3000000;
1144 pParamExt->sSpatialLayers[i].iSpatialBitrate = WELS_CLIP3 (bitrate, 500000, 3000000) ;
1145 pParamExt->iTargetBitrate += pParamExt->sSpatialLayers[i].iSpatialBitrate;
1146 pParamExt->sSpatialLayers[i].fFrameRate = 30;
1147 }
1148 int iResult = pPtrEnc->InitializeExt (pParamExt);
1149 const int kiFrameNumber = TEST_FRAMES;
1150
1151 m_iWidth = pParamExt->iPicWidth;
1152 m_iHeight = pParamExt->iPicHeight;
1153 m_iPicResSize = m_iWidth * m_iHeight * 3 >> 1;
1154 if (pYUV)
1155 delete []pYUV;
1156 pYUV = new unsigned char [m_iPicResSize];
1157 ASSERT_TRUE (pYUV != NULL);
1158 FileInputStream fileStream;
1159 ASSERT_TRUE (fileStream.Open ("res/Cisco_Absolute_Power_1280x720_30fps.yuv"));
1160 PrepareOneSrcFrame();
1161 for (int i = 0; i < kiFrameNumber; i ++) {
1162 if (fileStream.read (pYUV, m_iPicResSize) != m_iPicResSize) {
1163 break;
1164 }
1165 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
1166 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
1167 pSrcPic->uiTimeStamp += 30;
1168
1169 for (int i = 0; i < sFbi.iLayerNum; ++i) {
1170 for (int j = 0; j < sFbi.sLayerInfo[i].iNalCount; ++j) {
1171 int length = sFbi.sLayerInfo[i].pNalLengthInByte[j];
1172 EXPECT_LE (length, iMaxNalSize);
1173 }
1174 }
1175
1176 }
1177 pParamExt->iPicWidth = 1280;
1178 pParamExt->iPicHeight = 720;
1179 pParamExt->iPicWidth += (rand() << 1) % IMAGE_VARY_SIZE;
1180 pParamExt->iPicHeight += (rand() << 1) % IMAGE_VARY_SIZE;
1181 m_iWidth = pParamExt->iPicWidth;
1182 m_iHeight = pParamExt->iPicHeight;
1183 m_iPicResSize = m_iWidth * m_iHeight * 3 >> 1;
1184 delete []pYUV;
1185 pYUV = new unsigned char [m_iPicResSize];
1186 ASSERT_TRUE (pYUV != NULL);
1187 iResult = pPtrEnc->InitializeExt (pParamExt);
1188 PrepareOneSrcFrame();
1189
1190 ENCODER_OPTION eOptionId = ENCODER_OPTION_SVC_ENCODE_PARAM_EXT;
1191 memcpy (pOption, pParamExt, sizeof (SEncParamExt));
1192 pOption ->iPicWidth = m_iWidth;
1193 pOption ->iPicHeight = m_iHeight;
1194 iResult = pPtrEnc->SetOption (eOptionId, pOption);
1195 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
1196
1197 for (int i = 0; i < kiFrameNumber; i ++) {
1198 PrepareOneSrcFrame();
1199 iResult = pPtrEnc->EncodeFrame (pSrcPic, &sFbi);
1200 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
1201 pSrcPic->uiTimeStamp += 30;
1202
1203 for (int i = 0; i < sFbi.iLayerNum; ++i) {
1204 for (int j = 0; j < sFbi.sLayerInfo[i].iNalCount; ++j) {
1205 int length = sFbi.sLayerInfo[i].pNalLengthInByte[j];
1206 EXPECT_LE (length, iMaxNalSize);
1207 }
1208 }
1209 }
1210 iResult = pPtrEnc->Uninitialize();
1211 EXPECT_EQ (iResult, static_cast<int> (cmResultSuccess));
1212 }
1213