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 "videoenc_inner_sample.h"
28 #include "native_avcodec_videoencoder.h"
29 #include "native_avcodec_base.h"
30 #include "native_avcapability.h"
31 
32 using namespace std;
33 using namespace OHOS;
34 using namespace OHOS::Media;
35 using namespace testing::ext;
36 
37 namespace OHOS {
38 namespace Media {
39 class HwEncReliNdkTest : public testing::Test {
40 public:
41     static void SetUpTestCase();    // 第一个测试用例执行前
42     static void TearDownTestCase(); // 最后一个测试用例执行后
43     void SetUp() override;          // 每个测试用例执行前
44     void TearDown() override;       // 每个测试用例执行后
45     void InputFunc();
46     void OutputFunc();
47     void Release();
48     int32_t Stop();
49 
50 protected:
51     const char *inpDir720 = "/data/test/media/1280_720_nv.yuv";
52     const char *inpDir720Array[16] = {"/data/test/media/1280_720_nv.yuv",    "/data/test/media/1280_720_nv_1.yuv",
53                                       "/data/test/media/1280_720_nv_2.yuv",  "/data/test/media/1280_720_nv_3.yuv",
54                                       "/data/test/media/1280_720_nv_7.yuv",  "/data/test/media/1280_720_nv_10.yuv",
55                                       "/data/test/media/1280_720_nv_13.yuv", "/data/test/media/1280_720_nv_4.yuv",
56                                       "/data/test/media/1280_720_nv_8.yuv",  "/data/test/media/1280_720_nv_11.yuv",
57                                       "/data/test/media/1280_720_nv_14.yuv", "/data/test/media/1280_720_nv_5.yuv",
58                                       "/data/test/media/1280_720_nv_9.yuv",  "/data/test/media/1280_720_nv_12.yuv",
59                                       "/data/test/media/1280_720_nv_15.yuv", "/data/test/media/1280_720_nv_6.yuv"};
60     bool createCodecSuccess_ = false;
61 };
62 } // namespace Media
63 } // namespace OHOS
64 namespace {
65 OH_AVCapability *cap = nullptr;
66 OH_AVCapability *cap_hevc = nullptr;
67 string g_codecNameAvc;
68 string g_codecNameHEVC;
69 fileInfo file_640_480_rgba{"/data/test/media/640_480.rgba", GRAPHIC_PIXEL_FMT_RGBA_8888, 640, 480 };
70 fileInfo file_1280_536_nv21{"/data/test/media/1280_536_nv21.yuv", GRAPHIC_PIXEL_FMT_YCRCB_420_SP, 1280, 536 };
71 fileInfo file_1280_720_nv12{"/data/test/media/1280_720_nv12.yuv", GRAPHIC_PIXEL_FMT_YCBCR_420_SP, 1280, 720 };
72 fileInfo file_1920_816_rgba{"/data/test/media/1920_816.rgba", GRAPHIC_PIXEL_FMT_RGBA_8888, 1920, 816 };
73 fileInfo file_1920_1080_nv21{"/data/test/media/1920_1080_nv21.yuv", GRAPHIC_PIXEL_FMT_YCRCB_420_SP, 1920, 1080 };
74 fileInfo file_3840_2160_nv12{"/data/test/media/3840_2160_nv12.yuv", GRAPHIC_PIXEL_FMT_YCBCR_420_SP, 3840, 2160 };
75 fileInfo file_1280_720_nv12_10bit{"/data/test/media/1280_720_nv12_10bit.yuv", GRAPHIC_PIXEL_FMT_YCBCR_P010, 1280, 720 };
76 fileInfo file_1080_1920_nv12{"/data/test/media/1080_1920_nv12.yuv", GRAPHIC_PIXEL_FMT_YCBCR_420_SP, 1080, 1920 };
77 fileInfo file_1280_1280_nv12{"/data/test/media/1280_1280_nv12.yuv", GRAPHIC_PIXEL_FMT_YCBCR_420_SP, 1280, 1280 };
78 } // namespace
SetUpTestCase()79 void HwEncReliNdkTest::SetUpTestCase()
80 {
81     cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
82     g_codecNameAvc = OH_AVCapability_GetName(cap);
83     cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
84     g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
85 }
86 
TearDownTestCase()87 void HwEncReliNdkTest::TearDownTestCase() {}
88 
SetUp()89 void HwEncReliNdkTest::SetUp() {}
90 
TearDown()91 void HwEncReliNdkTest::TearDown() {}
92 
93 namespace {
94 /**
95  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0100
96  * @tc.name      : 720P
97  * @tc.desc      : reliable test
98  */
HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0100, TestSize.Level3)99 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0100, TestSize.Level3)
100 {
101     while (true) {
102         shared_ptr<VEncAPI11Sample> vEncSample = make_shared<VEncAPI11Sample>();
103         vEncSample->INP_DIR = inpDir720;
104         vEncSample->DEFAULT_WIDTH = 1280;
105         vEncSample->DEFAULT_HEIGHT = 720;
106         vEncSample->DEFAULT_FRAME_RATE = 30;
107         vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
108         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameAvc.c_str()));
109         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
110         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
111         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
112         vEncSample->WaitForEOS();
113         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
114     }
115 }
116 
117 /**
118  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0200
119  * @tc.name      : 16 instances
120  * @tc.desc      : reliable test
121  */
HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0200, TestSize.Level3)122 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0200, TestSize.Level3)
123 {
124     for (int i = 0; i < 16; i++) {
125         VEncAPI11Sample *vEncSample = new VEncAPI11Sample();
126         vEncSample->INP_DIR = inpDir720Array[i];
127         vEncSample->DEFAULT_WIDTH = 1280;
128         vEncSample->DEFAULT_HEIGHT = 720;
129         vEncSample->DEFAULT_FRAME_RATE = 30;
130         vEncSample->repeatRun = true;
131         vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
132         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameAvc.c_str()));
133         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
134         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
135         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
136         if (i == 15) {
137             vEncSample->WaitForEOS();
138             ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
139         }
140     }
141 }
142 
143 /**
144  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0300
145  * @tc.name      : long encode
146  * @tc.desc      : reliable test
147  */
HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0300, TestSize.Level3)148 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0300, TestSize.Level3)
149 {
150     shared_ptr<VEncAPI11Sample> vEncSample = make_shared<VEncAPI11Sample>();
151     vEncSample->INP_DIR = inpDir720;
152     vEncSample->DEFAULT_WIDTH = 1280;
153     vEncSample->DEFAULT_HEIGHT = 720;
154     vEncSample->DEFAULT_FRAME_RATE = 30;
155     vEncSample->repeatRun = true;
156     vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
157     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameAvc.c_str()));
158     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
159     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
160     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
161     vEncSample->WaitForEOS();
162     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
163 }
164 
165 /**
166  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0400
167  * @tc.name      : 16 instances
168  * @tc.desc      : reliable test
169  */
HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0400, TestSize.Level3)170 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0400, TestSize.Level3)
171 {
172     while (true) {
173         vector<shared_ptr<VEncAPI11Sample>> encVec;
174         for (int i = 0; i < 16; i++) {
175             auto vEncSample = make_shared<VEncAPI11Sample>();
176             encVec.push_back(vEncSample);
177             vEncSample->INP_DIR = inpDir720Array[i];
178             vEncSample->DEFAULT_WIDTH = 1280;
179             vEncSample->DEFAULT_HEIGHT = 720;
180             vEncSample->DEFAULT_FRAME_RATE = 30;
181             vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
182             ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameAvc.c_str()));
183             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
184             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
185             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
186         }
187         for (int i = 0; i < 16; i++) {
188             encVec[i]->WaitForEOS();
189         }
190     }
191 }
192 
193 /**
194  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0010
195  * @tc.name      : 16个线程 分层编码-reset-分层编码
196  * @tc.desc      : function test
197  */
HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0010, TestSize.Level3)198 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0010, TestSize.Level3)
199 {
200     int len = 256;
201     int loop = 0;
202     while (loop < 1) {
203         loop++;
204         cout << "loop: "<<loop<<endl;
205         vector<shared_ptr<VEncAPI11Sample>> encVec;
206         for (int i = 0; i < 16; i++) {
207             char file[256] = {};
208             sprintf_s(file, len, "/data/test/media/VIDEO_HWENC_RELI_WHILE_0010_%d.h265", i);
209             auto vEncSample = make_shared<VEncAPI11Sample>();
210             vEncSample->OUT_DIR = file;
211 
212             encVec.push_back(vEncSample);
213             vEncSample->INP_DIR = inpDir720Array[i];
214             vEncSample->TEMPORAL_ENABLE = true;
215             vEncSample->TEMPORAL_CONFIG = true;
216             ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC.c_str()));
217             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
218             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(i+2));
219             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
220             vEncSample->WaitForEOS();
221             ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
222             ASSERT_EQ(AV_ERR_OK, vEncSample->Reset());
223             vEncSample->TEMPORAL_ENABLE = false;
224             vEncSample->TEMPORAL_CONFIG = false;
225 
226             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
227             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(i+2));
228             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
229             vEncSample->WaitForEOS();
230             ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
231         }
232         for (int i = 0; i < 16; i++) {
233             encVec[i]->WaitForEOS();
234         }
235         encVec.clear();
236     }
237 }
238 
239 /**
240  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0020
241  * @tc.name      : 16个线程 分层编码-reset-普通编码
242  * @tc.desc      : function test
243  */
HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0020, TestSize.Level3)244 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0020, TestSize.Level3)
245 {
246     int len = 256;
247     int loop = 0;
248     while (loop < 1) {
249         loop++;
250         cout << "loop: "<<loop<<endl;
251         vector<shared_ptr<VEncAPI11Sample>> encVec;
252         for (int i = 0; i < 16; i++) {
253             char file[256] = {};
254             sprintf_s(file, len, "/data/test/media/VIDEO_HWENC_RELI_WHILE_0020_%d.h265", i);
255             auto vEncSample = make_shared<VEncAPI11Sample>();
256             vEncSample->OUT_DIR = file;
257 
258             encVec.push_back(vEncSample);
259             vEncSample->INP_DIR = inpDir720Array[i];
260             vEncSample->TEMPORAL_ENABLE = true;
261             vEncSample->TEMPORAL_CONFIG = true;
262             ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC.c_str()));
263             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
264             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(i+2));
265             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
266             vEncSample->WaitForEOS();
267             ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
268             ASSERT_EQ(AV_ERR_OK, vEncSample->Reset());
269             vEncSample->TEMPORAL_ENABLE = false;
270             vEncSample->TEMPORAL_CONFIG = false;
271 
272             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
273             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
274             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
275             vEncSample->WaitForEOS();
276             ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
277         }
278         for (int i = 0; i < 16; i++) {
279             encVec[i]->WaitForEOS();
280         }
281         encVec.clear();
282     }
283 }
284 
285 /**
286  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0030
287  * @tc.name      : h265 buffer 16个线程，8个相邻分层，8个跨帧分层1
288  * @tc.desc      : function test
289  */
HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0030, TestSize.Level3)290 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0030, TestSize.Level3)
291 {
292     int len =256;
293     int loop = 0;
294     while (loop < 1) {
295         loop++;
296         cout << "loop: "<<loop<<endl;
297         vector<shared_ptr<VEncAPI11Sample>> encVec;
298         for (int i = 0; i < 16; i++) {
299             char file[256] = {};
300             sprintf_s(file, len, "/data/test/media/VIDEO_HWENC_RELI_WHILE_0030_%d.h265", i);
301             auto vEncSample = make_shared<VEncAPI11Sample>();
302             vEncSample->OUT_DIR = file;
303 
304             encVec.push_back(vEncSample);
305             vEncSample->INP_DIR = inpDir720Array[i];
306             vEncSample->TEMPORAL_ENABLE = true;
307             vEncSample->TEMPORAL_CONFIG = true;
308             if (i % 2 == 0) {
309                 vEncSample->TEMPORAL_JUMP_MODE = true;
310             }
311             ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC.c_str()));
312             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
313             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(i));
314             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
315         }
316         for (int i = 0; i < 16; i++) {
317             encVec[i]->WaitForEOS();
318         }
319         encVec.clear();
320     }
321 }
322 
323 /**
324  * @tc.number    : VIDEO_HWENC_RELI_WHILE_0040
325  * @tc.name      : h265 surface 16个线程，8个相邻分层，8个跨帧分层
326  * @tc.desc      : function test
327  */
HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0040, TestSize.Level3)328 HWTEST_F(HwEncReliNdkTest, VIDEO_HWENC_RELI_WHILE_0040, TestSize.Level3)
329 {
330     int len =256;
331     int loop = 0;
332     while (loop < 10) {
333         loop++;
334         cout << "loop: "<<loop<<endl;
335         vector<shared_ptr<VEncAPI11Sample>> encVec;
336         for (int i = 0; i < 16; i++) {
337             char file[256] = {};
338             sprintf_s(file, len, "/data/test/media/VIDEO_HWENC_RELI_WHILE_0040_%d.h265", i);
339             auto vEncSample = make_shared<VEncAPI11Sample>();
340             vEncSample->OUT_DIR = file;
341 
342             encVec.push_back(vEncSample);
343             vEncSample->INP_DIR = inpDir720Array[i];
344             vEncSample->SURF_INPUT = true;
345             vEncSample->TEMPORAL_ENABLE = true;
346             vEncSample->TEMPORAL_CONFIG = true;
347             if (i % 2 == 0) {
348                 vEncSample->TEMPORAL_JUMP_MODE = true;
349             }
350             ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC.c_str()));
351             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
352             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(i));
353             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
354         }
355         for (int i = 0; i < 16; i++) {
356             encVec[i]->WaitForEOS();
357         }
358         encVec.clear();
359     }
360 }
361 /**
362  * @tc.number    : RESET_BITRATE_RELI_001
363  * @tc.name      : reset bitrate
364  * @tc.desc      : function test
365  */
HWTEST_F(HwEncReliNdkTest, RESET_BITRATE_RELI_001, TestSize.Level3)366 HWTEST_F(HwEncReliNdkTest, RESET_BITRATE_RELI_001, TestSize.Level3)
367 {
368     while (true) {
369         vector<shared_ptr<VEncAPI11Sample>> encVec;
370         for (int i = 0; i < 16; i++) {
371             auto vEncSample = make_shared<VEncAPI11Sample>();
372             encVec.push_back(vEncSample);
373             vEncSample->INP_DIR = inpDir720Array[i];
374             vEncSample->DEFAULT_WIDTH = 1280;
375             vEncSample->DEFAULT_HEIGHT = 720;
376             vEncSample->DEFAULT_FRAME_RATE = 30;
377             vEncSample->enableAutoSwitchParam =  true;
378             vEncSample->needResetBitrate = true;
379             vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
380             ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameAvc.c_str()));
381             ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
382             ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
383             ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
384         }
385         for (int i = 0; i < 16; i++) {
386             encVec[i]->WaitForEOS();
387         }
388         encVec.clear();
389     }
390 }
391 
392 /**
393  * @tc.number    : LTR_FUNC_017
394  * @tc.name      : 16个线程，8个为h265 surf普通编码，8个为h265 surf LTR编码
395  * @tc.desc      : function test
396  */
HWTEST_F(HwEncReliNdkTest, LTR_FUNC_017, TestSize.Level3)397 HWTEST_F(HwEncReliNdkTest, LTR_FUNC_017, TestSize.Level3)
398 {
399     while (true) {
400         vector<shared_ptr<VEncAPI11Sample>> encVec;
401         for (int i = 0; i < 16; i++) {
402             auto vEncApi11Sample = make_shared<VEncAPI11Sample>();
403             encVec.push_back(vEncApi11Sample);
404             vEncApi11Sample->INP_DIR = inpDir720Array[i];
405             vEncApi11Sample->DEFAULT_WIDTH = 1280;
406             vEncApi11Sample->DEFAULT_HEIGHT = 720;
407             vEncApi11Sample->DEFAULT_FRAME_RATE = 30;
408             vEncApi11Sample->DEFAULT_BITRATE_MODE = CBR;
409             vEncApi11Sample->SURF_INPUT = true;
410             vEncApi11Sample->DEFAULT_KEY_FRAME_INTERVAL = -1;
411             vEncApi11Sample->OUT_DIR = "/data/test/media/out/LTR_FUNC_017.h265";
412             if (i % 2 == 0) {
413                 vEncApi11Sample->ltrParam.enableUseLtr = true;
414                 vEncApi11Sample->ltrParam.ltrCount = 5;
415                 vEncApi11Sample->ltrParam.ltrInterval = 5;
416             }
417             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->CreateVideoEncoder(g_codecNameHEVC.c_str()));
418             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->SetVideoEncoderCallback());
419             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->ConfigureVideoEncoder());
420             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->StartVideoEncoder());
421         }
422         for (int i = 0; i < 16; i++) {
423             encVec[i]->WaitForEOS();
424         }
425         encVec.clear();
426     }
427 }
428 
429 /**
430  * @tc.number    : LTR_FUNC_018
431  * @tc.name      : 16个线程，8个为h264 buffer普通编码，8个为h265 surf LTR编码
432  * @tc.desc      : function test
433  */
HWTEST_F(HwEncReliNdkTest, LTR_FUNC_018, TestSize.Level3)434 HWTEST_F(HwEncReliNdkTest, LTR_FUNC_018, TestSize.Level3)
435 {
436     while (true) {
437         vector<shared_ptr<VEncAPI11Sample>> encVec;
438         for (int i = 0; i < 16; i++) {
439             auto vEncApi11Sample = make_shared<VEncAPI11Sample>();
440             encVec.push_back(vEncApi11Sample);
441             vEncApi11Sample->INP_DIR = inpDir720Array[i];
442             vEncApi11Sample->DEFAULT_WIDTH = 1280;
443             vEncApi11Sample->DEFAULT_HEIGHT = 720;
444             vEncApi11Sample->DEFAULT_FRAME_RATE = 30;
445             vEncApi11Sample->DEFAULT_BITRATE_MODE = CBR;
446             vEncApi11Sample->DEFAULT_KEY_FRAME_INTERVAL = -1;
447             vEncApi11Sample->OUT_DIR = "/data/test/media/out/LTR_FUNC_018.h265";
448             if (i % 2 == 0) {
449                 vEncApi11Sample->SURF_INPUT = true;
450                 vEncApi11Sample->ltrParam.enableUseLtr = true;
451                 vEncApi11Sample->ltrParam.ltrCount = 5;
452                 vEncApi11Sample->ltrParam.ltrInterval = 5;
453                 ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->CreateVideoEncoder(g_codecNameHEVC.c_str()));
454             } else {
455                 vEncApi11Sample->SURF_INPUT = false;
456                 vEncApi11Sample->ltrParam.enableUseLtr = false;
457                 ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->CreateVideoEncoder(g_codecNameAvc.c_str()));
458             }
459             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->SetVideoEncoderCallback());
460             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->ConfigureVideoEncoder());
461             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->StartVideoEncoder());
462         }
463         for (int i = 0; i < 16; i++) {
464             encVec[i]->WaitForEOS();
465         }
466         encVec.clear();
467     }
468 }
469 
470 /**
471  * @tc.number    : LTR_FUNC_019
472  * @tc.name      : 16个线程，8个为h264 surf普通编码，8个为h265 buffer LTR编码
473  * @tc.desc      : function test
474  */
HWTEST_F(HwEncReliNdkTest, LTR_FUNC_019, TestSize.Level3)475 HWTEST_F(HwEncReliNdkTest, LTR_FUNC_019, TestSize.Level3)
476 {
477     while (true) {
478         vector<shared_ptr<VEncAPI11Sample>> encVec;
479         for (int i = 0; i < 16; i++) {
480             auto vEncApi11Sample = make_shared<VEncAPI11Sample>();
481             encVec.push_back(vEncApi11Sample);
482             vEncApi11Sample->INP_DIR = inpDir720Array[i];
483             vEncApi11Sample->DEFAULT_WIDTH = 1280;
484             vEncApi11Sample->DEFAULT_HEIGHT = 720;
485             vEncApi11Sample->DEFAULT_FRAME_RATE = 30;
486             vEncApi11Sample->DEFAULT_BITRATE_MODE = CBR;
487             vEncApi11Sample->DEFAULT_KEY_FRAME_INTERVAL = -1;
488             vEncApi11Sample->OUT_DIR = "/data/test/media/out/LTR_FUNC_019.h265";
489             if (i % 2 == 0) {
490                 vEncApi11Sample->SURF_INPUT = false;
491                 vEncApi11Sample->ltrParam.enableUseLtr = true;
492                 vEncApi11Sample->ltrParam.ltrCount = 5;
493                 vEncApi11Sample->ltrParam.ltrInterval = 5;
494                 ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->CreateVideoEncoder(g_codecNameHEVC.c_str()));
495             } else {
496                 vEncApi11Sample->SURF_INPUT = true;
497                 vEncApi11Sample->ltrParam.enableUseLtr = false;
498                 ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->CreateVideoEncoder(g_codecNameAvc.c_str()));
499             }
500             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->SetVideoEncoderCallback());
501             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->ConfigureVideoEncoder());
502             ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->StartVideoEncoder());
503         }
504         for (int i = 0; i < 16; i++) {
505             encVec[i]->WaitForEOS();
506         }
507         encVec.clear();
508     }
509 }
510 
511 /**
512  * @tc.number    : VIDEO_ENCODE_INNER_MULTIFILE_0030
513  * @tc.name      : repeatedly surface change encode to call for 12 hours
514  * @tc.desc      : function test
515  */
HWTEST_F(HwEncInnerFuncNdkTest, VIDEO_ENCODE_INNER_MULTIFILE_RELI_0010, TestSize.Level3)516 HWTEST_F(HwEncInnerFuncNdkTest, VIDEO_ENCODE_INNER_MULTIFILE_RELI_0010, TestSize.Level3)
517 {
518     auto vEncInnerSample = make_unique<VEncNdkInnerSample>();
519     while (true) {
520         vEncInnerSample->DEFAULT_WIDTH = 3840;
521         vEncInnerSample->DEFAULT_HEIGHT = 2160;
522         vEncInnerSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_MULTIFILE_RELI_0010.h265";
523         vEncInnerSample->surfaceInput = true;
524         vEncInnerSample->readMultiFiles = true;
525         vEncInnerSample->fileInfos.push_back(file_640_480_rgba);
526         vEncInnerSample->fileInfos.push_back(file_1280_536_nv21);
527         vEncInnerSample->fileInfos.push_back(file_1280_720_nv12);
528         vEncInnerSample->fileInfos.push_back(file_1920_816_rgba);
529         vEncInnerSample->fileInfos.push_back(file_1920_1080_nv21);
530         vEncInnerSample->fileInfos.push_back(file_3840_2160_nv12);
531         ASSERT_EQ(AV_ERR_OK, vEncInnerSample->CreateByName(g_codecNameHevc));
532         ASSERT_EQ(AV_ERR_OK, vEncInnerSample->SetCallback());
533         ASSERT_EQ(AV_ERR_OK, vEncInnerSample->Configure());
534         ASSERT_EQ(AV_ERR_OK, vEncInnerSample->StartVideoEncoder());
535         vEncInnerSample->WaitForEOS();
536     }
537 }
538 } // namespace