1 /*
2  * Copyright (C) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <iostream>
17 #include <cstdio>
18 #include <atomic>
19 #include <fstream>
20 #include <thread>
21 #include <mutex>
22 #include <queue>
23 #include <string>
24 
25 #include "gtest/gtest.h"
26 #include "videoenc_api11_sample.h"
27 #include "native_avcodec_videoencoder.h"
28 #include "native_avcodec_base.h"
29 #include "native_avcapability.h"
30 
31 using namespace std;
32 using namespace OHOS;
33 using namespace OHOS::Media;
34 using namespace testing::ext;
35 
36 namespace OHOS {
37 namespace Media {
38 class HwEncReliNdkTest : public testing::Test {
39 public:
40     static void SetUpTestCase();    // 第一个测试用例执行前
41     static void TearDownTestCase(); // 最后一个测试用例执行后
42     void SetUp() override;          // 每个测试用例执行前
43     void TearDown() override;       // 每个测试用例执行后
44     void InputFunc();
45     void OutputFunc();
46     void Release();
47     int32_t Stop();
48 
49 protected:
50     const char *inpDir720 = "/data/test/media/1280_720_nv.yuv";
51     const char *inpDir720Array[16] = {"/data/test/media/1280_720_nv.yuv",    "/data/test/media/1280_720_nv_1.yuv",
52                                       "/data/test/media/1280_720_nv_2.yuv",  "/data/test/media/1280_720_nv_3.yuv",
53                                       "/data/test/media/1280_720_nv_7.yuv",  "/data/test/media/1280_720_nv_10.yuv",
54                                       "/data/test/media/1280_720_nv_13.yuv", "/data/test/media/1280_720_nv_4.yuv",
55                                       "/data/test/media/1280_720_nv_8.yuv",  "/data/test/media/1280_720_nv_11.yuv",
56                                       "/data/test/media/1280_720_nv_14.yuv", "/data/test/media/1280_720_nv_5.yuv",
57                                       "/data/test/media/1280_720_nv_9.yuv",  "/data/test/media/1280_720_nv_12.yuv",
58                                       "/data/test/media/1280_720_nv_15.yuv", "/data/test/media/1280_720_nv_6.yuv"};
59     bool createCodecSuccess_ = false;
60 };
61 } // namespace Media
62 } // namespace OHOS
63 namespace {
64 OH_AVCapability *cap = nullptr;
65 OH_AVCapability *cap_hevc = nullptr;
66 string g_codecNameAvc;
67 string g_codecNameHEVC;
68 } // namespace
SetUpTestCase()69 void HwEncReliNdkTest::SetUpTestCase()
70 {
71     cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
72     g_codecNameAvc = OH_AVCapability_GetName(cap);
73     cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
74     g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
75 }
76 
TearDownTestCase()77 void HwEncReliNdkTest::TearDownTestCase() {}
78 
SetUp()79 void HwEncReliNdkTest::SetUp() {}
80 
TearDown()81 void HwEncReliNdkTest::TearDown() {}
82 
83 namespace {
84 /**
85  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0100
86  * @tc.name      : 720P
87  * @tc.desc      : reliable test
88  */
89 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0100, TestSize.Level3)
90 {
91     while (true) {
92         shared_ptr<VEncAPI11Sample> vEncSample = make_shared<VEncAPI11Sample>();
93         vEncSample->INP_DIR = inpDir720;
94         vEncSample->DEFAULT_WIDTH = 1280;
95         vEncSample->DEFAULT_HEIGHT = 720;
96         vEncSample->DEFAULT_FRAME_RATE = 30;
97         vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
98         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameAvc.c_str()));
99         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
100         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
101         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
102         vEncSample->WaitForEOS();
103         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
104     }
105 }
106 
107 /**
108  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0200
109  * @tc.name      : 16 instances
110  * @tc.desc      : reliable test
111  */
112 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0200, TestSize.Level3)
113 {
114     for (int i = 0; i < 16; i++) {
115         VEncAPI11Sample *vEncSample = new VEncAPI11Sample();
116         vEncSample->INP_DIR = inpDir720Array[i];
117         vEncSample->DEFAULT_WIDTH = 1280;
118         vEncSample->DEFAULT_HEIGHT = 720;
119         vEncSample->DEFAULT_FRAME_RATE = 30;
120         vEncSample->repeatRun = true;
121         vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
122         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameAvc.c_str()));
123         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
124         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
125         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
126         if (i == 15) {
127             vEncSample->WaitForEOS();
128             ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
129         }
130     }
131 }
132 
133 /**
134  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0300
135  * @tc.name      : long encode
136  * @tc.desc      : reliable test
137  */
138 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0300, TestSize.Level3)
139 {
140     shared_ptr<VEncAPI11Sample> vEncSample = make_shared<VEncAPI11Sample>();
141     vEncSample->INP_DIR = inpDir720;
142     vEncSample->DEFAULT_WIDTH = 1280;
143     vEncSample->DEFAULT_HEIGHT = 720;
144     vEncSample->DEFAULT_FRAME_RATE = 30;
145     vEncSample->repeatRun = true;
146     vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
147     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameAvc.c_str()));
148     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
149     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
150     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
151     vEncSample->WaitForEOS();
152     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
153 }
154 
155 /**
156  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0400
157  * @tc.name      : 16 instances
158  * @tc.desc      : reliable test
159  */
160 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0400, TestSize.Level3)
161 {
162     while (true) {
163         vector<shared_ptr<VEncAPI11Sample>> encVec;
164         for (int i = 0; i < 16; i++) {
165             auto vEncSample = make_shared<VEncAPI11Sample>();
166             encVec.push_back(vEncSample);
167             vEncSample->INP_DIR = inpDir720Array[i];
168             vEncSample->DEFAULT_WIDTH = 1280;
169             vEncSample->DEFAULT_HEIGHT = 720;
170             vEncSample->DEFAULT_FRAME_RATE = 30;
171             vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
172             ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameAvc.c_str()));
173             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
174             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
175             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
176         }
177         for (int i = 0; i < 16; i++) {
178             encVec[i]->WaitForEOS();
179         }
180     }
181 }
182 
183 /**
184  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0010
185  * @tc.name      : 16个线程 分层编码-reset-分层编码
186  * @tc.desc      : function test
187  */
188 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0010, TestSize.Level3)
189 {
190     int len = 256;
191     int loop = 0;
192     while (loop < 1) {
193         loop++;
194         cout << "loop: "<<loop<<endl;
195         vector<shared_ptr<VEncAPI11Sample>> encVec;
196         for (int i = 0; i < 16; i++) {
197             char file[256] = {};
198             sprintf_s(file, len, "/data/test/media/VIDEO_HWENC_RELI_WHILE_0010_%d.h265", i);
199             auto vEncSample = make_shared<VEncAPI11Sample>();
200             vEncSample->OUT_DIR = file;
201 
202             encVec.push_back(vEncSample);
203             vEncSample->INP_DIR = inpDir720Array[i];
204             vEncSample->TEMPORAL_ENABLE = true;
205             vEncSample->TEMPORAL_CONFIG = true;
206             ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC.c_str()));
207             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
208             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(i+2));
209             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
210             vEncSample->WaitForEOS();
211             ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
212             ASSERT_EQ(AV_ERR_OK, vEncSample->Reset());
213             vEncSample->TEMPORAL_ENABLE = false;
214             vEncSample->TEMPORAL_CONFIG = false;
215 
216             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
217             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(i+2));
218             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
219             vEncSample->WaitForEOS();
220             ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
221         }
222         for (int i = 0; i < 16; i++) {
223             encVec[i]->WaitForEOS();
224         }
225         encVec.clear();
226     }
227 }
228 
229 /**
230  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0020
231  * @tc.name      : 16个线程 分层编码-reset-普通编码
232  * @tc.desc      : function test
233  */
234 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0020, TestSize.Level3)
235 {
236     int len = 256;
237     int loop = 0;
238     while (loop < 1) {
239         loop++;
240         cout << "loop: "<<loop<<endl;
241         vector<shared_ptr<VEncAPI11Sample>> encVec;
242         for (int i = 0; i < 16; i++) {
243             char file[256] = {};
244             sprintf_s(file, len, "/data/test/media/VIDEO_HWENC_RELI_WHILE_0020_%d.h265", i);
245             auto vEncSample = make_shared<VEncAPI11Sample>();
246             vEncSample->OUT_DIR = file;
247 
248             encVec.push_back(vEncSample);
249             vEncSample->INP_DIR = inpDir720Array[i];
250             vEncSample->TEMPORAL_ENABLE = true;
251             vEncSample->TEMPORAL_CONFIG = true;
252             ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC.c_str()));
253             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
254             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(i+2));
255             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
256             vEncSample->WaitForEOS();
257             ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
258             ASSERT_EQ(AV_ERR_OK, vEncSample->Reset());
259             vEncSample->TEMPORAL_ENABLE = false;
260             vEncSample->TEMPORAL_CONFIG = false;
261 
262             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
263             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
264             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
265             vEncSample->WaitForEOS();
266             ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
267         }
268         for (int i = 0; i < 16; i++) {
269             encVec[i]->WaitForEOS();
270         }
271         encVec.clear();
272     }
273 }
274 
275 /**
276  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0030
277  * @tc.name      : h265 buffer 16个线程，8个相邻分层，8个跨帧分层1
278  * @tc.desc      : function test
279  */
280 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0030, TestSize.Level3)
281 {
282     int len =256;
283     int loop = 0;
284     while (loop < 1) {
285         loop++;
286         cout << "loop: "<<loop<<endl;
287         vector<shared_ptr<VEncAPI11Sample>> encVec;
288         for (int i = 0; i < 16; i++) {
289             char file[256] = {};
290             sprintf_s(file, len, "/data/test/media/VIDEO_HWENC_RELI_WHILE_0030_%d.h265", i);
291             auto vEncSample = make_shared<VEncAPI11Sample>();
292             vEncSample->OUT_DIR = file;
293 
294             encVec.push_back(vEncSample);
295             vEncSample->INP_DIR = inpDir720Array[i];
296             vEncSample->TEMPORAL_ENABLE = true;
297             vEncSample->TEMPORAL_CONFIG = true;
298             if (i % 2 == 0) {
299                 vEncSample->TEMPORAL_JUMP_MODE = true;
300             }
301             ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC.c_str()));
302             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
303             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(i));
304             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
305         }
306         for (int i = 0; i < 16; i++) {
307             encVec[i]->WaitForEOS();
308         }
309         encVec.clear();
310     }
311 }
312 
313 /**
314  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0040
315  * @tc.name      : h265 surface 16个线程，8个相邻分层，8个跨帧分层
316  * @tc.desc      : function test
317  */
318 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0040, TestSize.Level3)
319 {
320     int len =256;
321     int loop = 0;
322     while (loop < 10) {
323         loop++;
324         cout << "loop: "<<loop<<endl;
325         vector<shared_ptr<VEncAPI11Sample>> encVec;
326         for (int i = 0; i < 16; i++) {
327             char file[256] = {};
328             sprintf_s(file, len, "/data/test/media/VIDEO_HWENC_RELI_WHILE_0040_%d.h265", i);
329             auto vEncSample = make_shared<VEncAPI11Sample>();
330             vEncSample->OUT_DIR = file;
331 
332             encVec.push_back(vEncSample);
333             vEncSample->INP_DIR = inpDir720Array[i];
334             vEncSample->SURF_INPUT = true;
335             vEncSample->TEMPORAL_ENABLE = true;
336             vEncSample->TEMPORAL_CONFIG = true;
337             if (i % 2 == 0) {
338                 vEncSample->TEMPORAL_JUMP_MODE = true;
339             }
340             ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC.c_str()));
341             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
342             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(i));
343             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
344         }
345         for (int i = 0; i < 16; i++) {
346             encVec[i]->WaitForEOS();
347         }
348         encVec.clear();
349     }
350 }
351 /**
352  * @tc.number    : RESET_BITRATE_RELI_001
353  * @tc.name      : reset bitrate
354  * @tc.desc      : function test
355  */
356 HWTEST_F(HwEncReliNdkTest, RESET_BITRATE_RELI_001, TestSize.Level3)
357 {
358     while (true) {
359         vector<shared_ptr<VEncAPI11Sample>> encVec;
360         for (int i = 0; i < 16; i++) {
361             auto vEncSample = make_shared<VEncAPI11Sample>();
362             encVec.push_back(vEncSample);
363             vEncSample->INP_DIR = inpDir720Array[i];
364             vEncSample->DEFAULT_WIDTH = 1280;
365             vEncSample->DEFAULT_HEIGHT = 720;
366             vEncSample->DEFAULT_FRAME_RATE = 30;
367             vEncSample->enableAutoSwitchParam =  true;
368             vEncSample->needResetBitrate = true;
369             vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
370             ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameAvc.c_str()));
371             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
372             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
373             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
374         }
375         for (int i = 0; i < 16; i++) {
376             encVec[i]->WaitForEOS();
377         }
378         encVec.clear();
379     }
380 }
381 
382 /**
383  * @tc.number    : LTR_FUNC_017
384  * @tc.name      : 16个线程，8个为h265 surf普通编码，8个为h265 surf LTR编码
385  * @tc.desc      : function test
386  */
387 HWTEST_F(HwEncReliNdkTest, LTR_FUNC_017, TestSize.Level3)
388 {
389     while (true) {
390         vector<shared_ptr<VEncAPI11Sample>> encVec;
391         for (int i = 0; i < 16; i++) {
392             auto vEncApi11Sample = make_shared<VEncAPI11Sample>();
393             encVec.push_back(vEncApi11Sample);
394             vEncApi11Sample->INP_DIR = inpDir720Array[i];
395             vEncApi11Sample->DEFAULT_WIDTH = 1280;
396             vEncApi11Sample->DEFAULT_HEIGHT = 720;
397             vEncApi11Sample->DEFAULT_FRAME_RATE = 30;
398             vEncApi11Sample->DEFAULT_BITRATE_MODE = CBR;
399             vEncApi11Sample->SURF_INPUT = true;
400             vEncApi11Sample->DEFAULT_KEY_FRAME_INTERVAL = -1;
401             vEncApi11Sample->OUT_DIR = "/data/test/media/out/LTR_FUNC_017.h265";
402             if (i % 2 == 0) {
403                 vEncApi11Sample->ltrParam.enableUseLtr = true;
404                 vEncApi11Sample->ltrParam.ltrCount = 5;
405                 vEncApi11Sample->ltrParam.ltrInterval = 5;
406             }
407             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->CreateVideoEncoder(g_codecNameHEVC.c_str()));
408             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->SetVideoEncoderCallback());
409             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->ConfigureVideoEncoder());
410             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->StartVideoEncoder());
411         }
412         for (int i = 0; i < 16; i++) {
413             encVec[i]->WaitForEOS();
414         }
415         encVec.clear();
416     }
417 }
418 
419 /**
420  * @tc.number    : LTR_FUNC_018
421  * @tc.name      : 16个线程，8个为h264 buffer普通编码，8个为h265 surf LTR编码
422  * @tc.desc      : function test
423  */
424 HWTEST_F(HwEncReliNdkTest, LTR_FUNC_018, TestSize.Level3)
425 {
426     while (true) {
427         vector<shared_ptr<VEncAPI11Sample>> encVec;
428         for (int i = 0; i < 16; i++) {
429             auto vEncApi11Sample = make_shared<VEncAPI11Sample>();
430             encVec.push_back(vEncApi11Sample);
431             vEncApi11Sample->INP_DIR = inpDir720Array[i];
432             vEncApi11Sample->DEFAULT_WIDTH = 1280;
433             vEncApi11Sample->DEFAULT_HEIGHT = 720;
434             vEncApi11Sample->DEFAULT_FRAME_RATE = 30;
435             vEncApi11Sample->DEFAULT_BITRATE_MODE = CBR;
436             vEncApi11Sample->DEFAULT_KEY_FRAME_INTERVAL = -1;
437             vEncApi11Sample->OUT_DIR = "/data/test/media/out/LTR_FUNC_018.h265";
438             if (i % 2 == 0) {
439                 vEncApi11Sample->SURF_INPUT = true;
440                 vEncApi11Sample->ltrParam.enableUseLtr = true;
441                 vEncApi11Sample->ltrParam.ltrCount = 5;
442                 vEncApi11Sample->ltrParam.ltrInterval = 5;
443                 ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->CreateVideoEncoder(g_codecNameHEVC.c_str()));
444             } else {
445                 vEncApi11Sample->SURF_INPUT = false;
446                 vEncApi11Sample->ltrParam.enableUseLtr = false;
447                 ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->CreateVideoEncoder(g_codecNameAvc.c_str()));
448             }
449             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->SetVideoEncoderCallback());
450             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->ConfigureVideoEncoder());
451             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->StartVideoEncoder());
452         }
453         for (int i = 0; i < 16; i++) {
454             encVec[i]->WaitForEOS();
455         }
456         encVec.clear();
457     }
458 }
459 
460 /**
461  * @tc.number    : LTR_FUNC_019
462  * @tc.name      : 16个线程，8个为h264 surf普通编码，8个为h265 buffer LTR编码
463  * @tc.desc      : function test
464  */
465 HWTEST_F(HwEncReliNdkTest, LTR_FUNC_019, TestSize.Level3)
466 {
467     while (true) {
468         vector<shared_ptr<VEncAPI11Sample>> encVec;
469         for (int i = 0; i < 16; i++) {
470             auto vEncApi11Sample = make_shared<VEncAPI11Sample>();
471             encVec.push_back(vEncApi11Sample);
472             vEncApi11Sample->INP_DIR = inpDir720Array[i];
473             vEncApi11Sample->DEFAULT_WIDTH = 1280;
474             vEncApi11Sample->DEFAULT_HEIGHT = 720;
475             vEncApi11Sample->DEFAULT_FRAME_RATE = 30;
476             vEncApi11Sample->DEFAULT_BITRATE_MODE = CBR;
477             vEncApi11Sample->DEFAULT_KEY_FRAME_INTERVAL = -1;
478             vEncApi11Sample->OUT_DIR = "/data/test/media/out/LTR_FUNC_019.h265";
479             if (i % 2 == 0) {
480                 vEncApi11Sample->SURF_INPUT = false;
481                 vEncApi11Sample->ltrParam.enableUseLtr = true;
482                 vEncApi11Sample->ltrParam.ltrCount = 5;
483                 vEncApi11Sample->ltrParam.ltrInterval = 5;
484                 ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->CreateVideoEncoder(g_codecNameHEVC.c_str()));
485             } else {
486                 vEncApi11Sample->SURF_INPUT = true;
487                 vEncApi11Sample->ltrParam.enableUseLtr = false;
488                 ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->CreateVideoEncoder(g_codecNameAvc.c_str()));
489             }
490             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->SetVideoEncoderCallback());
491             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->ConfigureVideoEncoder());
492             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->StartVideoEncoder());
493         }
494         for (int i = 0; i < 16; i++) {
495             encVec[i]->WaitForEOS();
496         }
497         encVec.clear();
498     }
499 }
500 } // namespace