1 /*
2  * Copyright (C) 2024 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 #include <string>
16 
17 #include "gtest/gtest.h"
18 #include "native_avcodec_videoencoder.h"
19 #include "native_averrors.h"
20 #include "videoenc_api11_sample.h"
21 #include "native_avcodec_base.h"
22 #include "avcodec_codec_name.h"
23 #include "native_avcapability.h"
24 
25 namespace {
26 OH_AVCodec *venc_ = NULL;
27 OH_AVCapability *cap = nullptr;
28 OH_AVCapability *cap_hevc = nullptr;
29 constexpr uint32_t CODEC_NAME_SIZE = 128;
30 char g_codecName[CODEC_NAME_SIZE] = {};
31 char g_codecNameHEVC[CODEC_NAME_SIZE] = {};
32 OH_AVFormat *format;
33 constexpr uint32_t DEFAULT_WIDTH = 1280;
34 constexpr uint32_t DEFAULT_HEIGHT = 720;
35 constexpr uint32_t DEFAULT_KEY_FRAME_INTERVAL = 1000;
36 constexpr uint32_t DEFAULT_BITRATE = 10000000;
37 constexpr double DEFAULT_FRAME_RATE = 30.0;
38 OH_AVPixelFormat DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
39 const char *INP_DIR_720 = "/data/test/media/1280_720_nv.yuv";
40 } // namespace
41 namespace OHOS {
42 namespace Media {
43 class HwEncTemporalNdkTest : public testing::Test {
44 public:
45     static void SetUpTestCase();
46     static void TearDownTestCase();
47     void SetUp() override;
48     void TearDown() override;
49     void InputFunc();
50     void OutputFunc();
51     void Release();
52     int32_t Stop();
53 
54 protected:
55     const char *inpDir720 = "/data/test/media/1280_720_nv.yuv";
56     const char *inpDir720Array[16] = {"/data/test/media/1280_720_nv.yuv",    "/data/test/media/1280_720_nv_1.yuv",
57                                       "/data/test/media/1280_720_nv_2.yuv",  "/data/test/media/1280_720_nv_3.yuv",
58                                       "/data/test/media/1280_720_nv_7.yuv",  "/data/test/media/1280_720_nv_10.yuv",
59                                       "/data/test/media/1280_720_nv_13.yuv", "/data/test/media/1280_720_nv_4.yuv",
60                                       "/data/test/media/1280_720_nv_8.yuv",  "/data/test/media/1280_720_nv_11.yuv",
61                                       "/data/test/media/1280_720_nv_14.yuv", "/data/test/media/1280_720_nv_5.yuv",
62                                       "/data/test/media/1280_720_nv_9.yuv",  "/data/test/media/1280_720_nv_12.yuv",
63                                       "/data/test/media/1280_720_nv_15.yuv", "/data/test/media/1280_720_nv_6.yuv"};
64 };
65 } // namespace Media
66 } // namespace OHOS
67 
68 using namespace std;
69 using namespace OHOS;
70 using namespace OHOS::Media;
71 using namespace testing::ext;
72 
SetUpTestCase()73 void HwEncTemporalNdkTest::SetUpTestCase()
74 {
75     cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
76     const char *tmpCodecName = OH_AVCapability_GetName(cap);
77     if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
78         cout << "memcpy failed" << endl;
79     cout << "codecname: " << g_codecName << endl;
80     cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
81     const char *tmpCodecNameHevc = OH_AVCapability_GetName(cap_hevc);
82     if (memcpy_s(g_codecNameHEVC, sizeof(g_codecNameHEVC), tmpCodecNameHevc, strlen(tmpCodecNameHevc)) != 0)
83         cout << "memcpy failed" << endl;
84     cout << "codecname_hevc: " << g_codecNameHEVC << endl;
85 }
TearDownTestCase()86 void HwEncTemporalNdkTest::TearDownTestCase() {}
SetUp()87 void HwEncTemporalNdkTest::SetUp() {}
TearDown()88 void HwEncTemporalNdkTest::TearDown()
89 {
90     if (venc_ != NULL) {
91         OH_VideoEncoder_Destroy(venc_);
92         venc_ = nullptr;
93     }
94     if (format != nullptr) {
95         OH_AVFormat_Destroy(format);
96         format = nullptr;
97     }
98 }
99 namespace {
100 /**
101  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0020
102  * @tc.name      : OOH_MD_KEY_VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE error
103  * @tc.desc      : api test
104  */
105 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_API_0020, TestSize.Level2)
106 {
107     OH_AVErrCode ret = AV_ERR_OK;
108     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
109     ASSERT_NE(nullptr, venc_);
110     format = OH_AVFormat_Create();
111     ASSERT_NE(nullptr, format);
112 
113     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
114     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
115     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, DEFAULT_PIX_FMT);
116     (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
117     (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
118     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, DEFAULT_KEY_FRAME_INTERVAL);
119     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
120     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_TEMPORAL_GOP_REFERENCE_MODE, 3);
121     ret = OH_VideoEncoder_Configure(venc_, format);
122     if (!access("/system/lib64/media/", 0)) {
123         ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
124     } else {
125         ASSERT_EQ(ret, AV_ERR_OK);
126     }
127 }
128 
129 /**
130  * @tc.number    : VIDEO_TEMPORAL_ENCODE_API_0030
131  * @tc.name      : OH_MD_KEY_VIDEO_ENCODER_TEMPORAL_GOP_SIZE para error
132  * @tc.desc      : api test
133  */
134 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_API_0030, TestSize.Level2)
135 {
136     OH_AVErrCode ret = AV_ERR_OK;
137     venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
138     ASSERT_NE(nullptr, venc_);
139     format = OH_AVFormat_Create();
140     ASSERT_NE(nullptr, format);
141 
142     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
143     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
144     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, DEFAULT_PIX_FMT);
145     (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
146     (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
147     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, DEFAULT_KEY_FRAME_INTERVAL);
148     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_ENABLE_TEMPORAL_SCALABILITY, 1);
149     (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_TEMPORAL_GOP_SIZE, 30);
150     ret = OH_VideoEncoder_Configure(venc_, format);
151     if (!access("/system/lib64/media/", 0)) {
152         ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
153     } else {
154         ASSERT_EQ(ret, AV_ERR_OK);
155     }
156 }
157 
158 /**
159  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0010
160  * @tc.name      : 调用使能接口
161  * @tc.desc      : api test
162  */
163 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0010, TestSize.Level1)
164 {
165     int32_t temporalGopSize = 2;
166     if (!access("/system/lib64/media/", 0)) {
167         auto vEncSample = make_unique<VEncAPI11Sample>();
168         cout << "running on phone=========="<< endl;
169         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
170         vEncSample->TEMPORAL_ENABLE = true;
171         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
172     } else {
173         auto vEncSample = make_unique<VEncAPI11Sample>();
174         cout << "running on rk=========="<< endl;
175         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
176         vEncSample->TEMPORAL_ENABLE = true;
177         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
178     }
179 }
180 
181 /**
182  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0020
183  * @tc.name      : 未使能，配置相邻模式分层编码,h264 buffer
184  * @tc.desc      : api test
185  */
186 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0020, TestSize.Level1)
187 {
188     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
189         auto vEncSample = make_unique<VEncAPI11Sample>();
190         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0020.h264";
191         vEncSample->INP_DIR = INP_DIR_720;
192         vEncSample->DEFAULT_WIDTH = 1280;
193         vEncSample->DEFAULT_HEIGHT = 720;
194         vEncSample->DEFAULT_FRAME_RATE = 30;
195         vEncSample->TEMPORAL_ENABLE = false;
196         vEncSample->TEMPORAL_CONFIG = true;
197         int32_t temporalGopSize = 2;
198         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
199         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
200         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
201         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
202         vEncSample->WaitForEOS();
203         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
204     }
205 }
206 
207 /**
208  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0030
209  * @tc.name      : 未使能，配置相邻模式分层编码,h265 surf
210  * @tc.desc      : api test
211  */
212 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0030, TestSize.Level1)
213 {
214     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
215         auto vEncSample = make_unique<VEncAPI11Sample>();
216         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0030.h265";
217         vEncSample->INP_DIR = INP_DIR_720;
218         vEncSample->DEFAULT_WIDTH = 1280;
219         vEncSample->DEFAULT_HEIGHT = 720;
220         vEncSample->DEFAULT_FRAME_RATE = 30;
221         vEncSample->SURF_INPUT = true;
222         vEncSample->TEMPORAL_ENABLE = false;
223         vEncSample->TEMPORAL_CONFIG = true;
224         int32_t temporalGopSize = 2;
225         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
226         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
227         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
228         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
229         vEncSample->WaitForEOS();
230         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
231     }
232 }
233 
234 /**
235  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0040
236  * @tc.name      : 配置跨帧模式分层编码,默认gopsize,h265 surf
237  * @tc.desc      : api test
238  */
239 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0040, TestSize.Level1)
240 {
241     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
242         auto vEncSample = make_unique<VEncAPI11Sample>();
243         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0040.h265";
244         vEncSample->INP_DIR = INP_DIR_720;
245         vEncSample->DEFAULT_WIDTH = 1280;
246         vEncSample->DEFAULT_HEIGHT = 720;
247         vEncSample->DEFAULT_FRAME_RATE = 30;
248         vEncSample->SURF_INPUT = true;
249         vEncSample->TEMPORAL_ENABLE = true;
250         vEncSample->TEMPORAL_DEFAULT = true;
251         vEncSample->TEMPORAL_JUMP_MODE = true;
252         int32_t temporalGopSize = 0;
253         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
254         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
255         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
256         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
257         vEncSample->WaitForEOS();
258         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
259     }
260 }
261 
262 /**
263  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0440
264  * @tc.name      : 配置相邻模式分层编码,默认gopsize,h265 surf
265  * @tc.desc      : api test
266  */
267 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0440, TestSize.Level1)
268 {
269     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
270         auto vEncSample = make_unique<VEncAPI11Sample>();
271         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0440.h265";
272         vEncSample->INP_DIR = INP_DIR_720;
273         vEncSample->DEFAULT_WIDTH = 1280;
274         vEncSample->DEFAULT_HEIGHT = 720;
275         vEncSample->DEFAULT_FRAME_RATE = 30;
276         vEncSample->SURF_INPUT = true;
277         vEncSample->TEMPORAL_ENABLE = true;
278         vEncSample->TEMPORAL_DEFAULT = true;
279         int32_t temporalGopSize = 0;
280         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
281         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
282         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
283         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
284         vEncSample->WaitForEOS();
285         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
286     }
287 }
288 
289 /**
290  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0050
291  * @tc.name      : h265，surf相邻参考模式分层编码。时域gop size为2
292  * @tc.desc      : function test
293  */
294 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0050, TestSize.Level1)
295 {
296     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
297         auto vEncSample = make_unique<VEncAPI11Sample>();
298         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0050.h265";
299         vEncSample->INP_DIR = INP_DIR_720;
300         vEncSample->DEFAULT_WIDTH = 1280;
301         vEncSample->DEFAULT_HEIGHT = 720;
302         vEncSample->DEFAULT_FRAME_RATE = 30;
303         vEncSample->SURF_INPUT = true;
304         vEncSample->TEMPORAL_ENABLE = true;
305         vEncSample->TEMPORAL_CONFIG = true;
306         int32_t temporalGopSize = 2;
307         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
308         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
309         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
310         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
311         vEncSample->WaitForEOS();
312         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
313     }
314 }
315 
316 /**
317  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0060
318  * @tc.name      : h265，surf相邻参考模式分层编码。时域gop size为I帧间隔-1
319  * @tc.desc      : function test
320  */
321 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0060, TestSize.Level1)
322 {
323     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
324         auto vEncSample = make_unique<VEncAPI11Sample>();
325         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0060.h265";
326         vEncSample->INP_DIR = INP_DIR_720;
327         vEncSample->DEFAULT_WIDTH = 1280;
328         vEncSample->DEFAULT_HEIGHT = 720;
329         vEncSample->DEFAULT_FRAME_RATE = 30;
330         vEncSample->SURF_INPUT = true;
331         vEncSample->TEMPORAL_ENABLE = true;
332         vEncSample->TEMPORAL_CONFIG = true;
333 
334         int32_t temporalGopSize = vEncSample->DEFAULT_FRAME_RATE-1;
335         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
336         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
337         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
338         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
339         vEncSample->WaitForEOS();
340         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
341     }
342 }
343 
344 /**
345  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0070
346  * @tc.name      : h265，surf跨帧参考模式分层编码。时域gop size为2
347  * @tc.desc      : function test
348  */
349 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0070, TestSize.Level1)
350 {
351     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
352         auto vEncSample = make_unique<VEncAPI11Sample>();
353         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0070.h265";
354         vEncSample->INP_DIR = INP_DIR_720;
355         vEncSample->DEFAULT_WIDTH = 1280;
356         vEncSample->DEFAULT_HEIGHT = 720;
357         vEncSample->DEFAULT_FRAME_RATE = 30;
358         vEncSample->SURF_INPUT = true;
359         vEncSample->TEMPORAL_ENABLE = true;
360         vEncSample->TEMPORAL_CONFIG = true;
361         vEncSample->TEMPORAL_JUMP_MODE = true;
362         int32_t temporalGopSize = 2;
363         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
364         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
365         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
366         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
367         vEncSample->WaitForEOS();
368         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
369     }
370 }
371 
372 /**
373  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0080
374  * @tc.name      : h265，surf跨帧参考模式分层编码  时域gop size为I帧间隔-1
375  * @tc.desc      : function test
376  */
377 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0080, TestSize.Level1)
378 {
379     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
380         auto vEncSample = make_unique<VEncAPI11Sample>();
381         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0080.h265";
382         vEncSample->INP_DIR = INP_DIR_720;
383         vEncSample->DEFAULT_WIDTH = 1280;
384         vEncSample->DEFAULT_HEIGHT = 720;
385         vEncSample->DEFAULT_FRAME_RATE = 30;
386         vEncSample->SURF_INPUT = true;
387         vEncSample->TEMPORAL_ENABLE = true;
388         vEncSample->TEMPORAL_CONFIG = true;
389         vEncSample->TEMPORAL_JUMP_MODE = true;
390         int32_t temporalGopSize = vEncSample->DEFAULT_FRAME_RATE-1;
391         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
392         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
393         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
394         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
395         vEncSample->WaitForEOS();
396         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
397     }
398 }
399 
400 /**
401  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0090
402  * @tc.name      : h264 buffer 相邻参考模式分层编码 时域gop size为任意合法值
403  * @tc.desc      : function test
404  */
405 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0090, TestSize.Level1)
406 {
407     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
408         auto vEncSample = make_unique<VEncAPI11Sample>();
409         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0090.h264";
410         vEncSample->INP_DIR = INP_DIR_720;
411         vEncSample->DEFAULT_WIDTH = 1280;
412         vEncSample->DEFAULT_HEIGHT = 720;
413         vEncSample->DEFAULT_FRAME_RATE = 30;
414         vEncSample->TEMPORAL_ENABLE = true;
415         vEncSample->TEMPORAL_CONFIG = true;
416         int32_t temporalGopSize = 3;
417         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
418         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
419         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
420         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
421         vEncSample->WaitForEOS();
422         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
423     }
424 }
425 
426 /**
427  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0100
428  * @tc.name      : h264 buffer 跨帧参考模式分层编码 时域gop size为任意合法值
429  * @tc.desc      : function test
430  */
431 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0100, TestSize.Level1)
432 {
433     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
434         auto vEncSample = make_unique<VEncAPI11Sample>();
435         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0100.h264";
436         vEncSample->INP_DIR = INP_DIR_720;
437         vEncSample->DEFAULT_WIDTH = 1280;
438         vEncSample->DEFAULT_HEIGHT = 720;
439         vEncSample->DEFAULT_FRAME_RATE = 30;
440         vEncSample->TEMPORAL_ENABLE = true;
441         vEncSample->TEMPORAL_CONFIG = true;
442         vEncSample->TEMPORAL_JUMP_MODE = true;
443         int32_t temporalGopSize = 3;
444         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
445         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
446         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
447         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
448         vEncSample->WaitForEOS();
449         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
450     }
451 }
452 
453 /**
454  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0110
455  * @tc.name      : h264 surf 相邻参考模式分层编码 时域gop size为任意合法值
456  * @tc.desc      : function test
457  */
458 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0110, TestSize.Level1)
459 {
460     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
461         auto vEncSample = make_unique<VEncAPI11Sample>();
462         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0110.h264";
463         vEncSample->INP_DIR = INP_DIR_720;
464         vEncSample->DEFAULT_WIDTH = 1280;
465         vEncSample->DEFAULT_HEIGHT = 720;
466         vEncSample->DEFAULT_FRAME_RATE = 30;
467         vEncSample->SURF_INPUT = true;
468         vEncSample->TEMPORAL_ENABLE = true;
469         vEncSample->TEMPORAL_CONFIG = true;
470         int32_t temporalGopSize = 5;
471         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
472         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
473         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
474         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
475         vEncSample->WaitForEOS();
476         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
477     }
478 }
479 
480 /**
481  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0120
482  * @tc.name      : h264 surf 跨帧参考模式分层编码 时域gop size为5
483  * @tc.desc      : function test
484  */
485 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0120, TestSize.Level1)
486 {
487     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
488         auto vEncSample = make_unique<VEncAPI11Sample>();
489         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0120.h264";
490         vEncSample->INP_DIR = INP_DIR_720;
491         vEncSample->DEFAULT_WIDTH = 1280;
492         vEncSample->DEFAULT_HEIGHT = 720;
493         vEncSample->DEFAULT_FRAME_RATE = 30;
494         vEncSample->SURF_INPUT = true;
495         vEncSample->TEMPORAL_ENABLE = true;
496         vEncSample->TEMPORAL_CONFIG = true;
497         vEncSample->TEMPORAL_JUMP_MODE = true;
498         int32_t temporalGopSize = 5;
499         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
500         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
501         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
502         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
503         vEncSample->WaitForEOS();
504         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
505     }
506 }
507 
508 /**
509  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0130
510  * @tc.name      : h265 buffer 相邻参考模式分层编码 时域gop size为任意合法值
511  * @tc.desc      : function test
512  */
513 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0130, TestSize.Level1)
514 {
515     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
516         auto vEncSample = make_unique<VEncAPI11Sample>();
517         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0130.h265";
518         vEncSample->INP_DIR = INP_DIR_720;
519         vEncSample->DEFAULT_WIDTH = 1280;
520         vEncSample->DEFAULT_HEIGHT = 720;
521         vEncSample->DEFAULT_FRAME_RATE = 30;
522         vEncSample->TEMPORAL_ENABLE = true;
523         vEncSample->TEMPORAL_CONFIG = true;
524         int32_t temporalGopSize = 6;
525         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
526         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
527         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
528         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
529         vEncSample->WaitForEOS();
530         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
531     }
532 }
533 
534 /**
535  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0140
536  * @tc.name      : h265 buffer 跨帧参考模式分层编码 时域gop size为8
537  * @tc.desc      : function test
538  */
539 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0140, TestSize.Level1)
540 {
541     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
542         auto vEncSample = make_unique<VEncAPI11Sample>();
543         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0140.h265";
544         vEncSample->INP_DIR = INP_DIR_720;
545         vEncSample->DEFAULT_WIDTH = 1280;
546         vEncSample->DEFAULT_HEIGHT = 720;
547         vEncSample->DEFAULT_FRAME_RATE = 30;
548         vEncSample->TEMPORAL_ENABLE = true;
549         vEncSample->TEMPORAL_CONFIG = true;
550         vEncSample->TEMPORAL_JUMP_MODE = true;
551         int32_t temporalGopSize = 8;
552         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
553         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
554         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
555         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
556         vEncSample->WaitForEOS();
557         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
558     }
559 }
560 
561 /**
562  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0150
563  * @tc.name      : h265 surf 相邻参考模式分层编码 时域gop size为任意合法值
564  * @tc.desc      : function test
565  */
566 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0150, TestSize.Level1)
567 {
568     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
569         auto vEncSample = make_unique<VEncAPI11Sample>();
570         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0150.h265";
571         vEncSample->INP_DIR = INP_DIR_720;
572         vEncSample->DEFAULT_WIDTH = 1280;
573         vEncSample->DEFAULT_HEIGHT = 720;
574         vEncSample->DEFAULT_FRAME_RATE = 30;
575         vEncSample->SURF_INPUT = true;
576         vEncSample->TEMPORAL_ENABLE = true;
577         vEncSample->TEMPORAL_CONFIG = true;
578         int32_t temporalGopSize = 9;
579         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
580         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
581         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
582         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
583         vEncSample->WaitForEOS();
584         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
585     }
586 }
587 
588 /**
589  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0160
590  * @tc.name      : h265 surf 跨帧参考模式分层编码 时域gop size为12
591  * @tc.desc      : function test
592  */
593 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0160, TestSize.Level1)
594 {
595     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
596         auto vEncSample = make_unique<VEncAPI11Sample>();
597         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0160.h265";
598         vEncSample->INP_DIR = INP_DIR_720;
599         vEncSample->DEFAULT_WIDTH = 1280;
600         vEncSample->DEFAULT_HEIGHT = 720;
601         vEncSample->DEFAULT_FRAME_RATE = 30;
602         vEncSample->SURF_INPUT = true;
603         vEncSample->TEMPORAL_ENABLE = true;
604         vEncSample->TEMPORAL_CONFIG = true;
605         vEncSample->TEMPORAL_JUMP_MODE = true;
606         int32_t temporalGopSize = 12;
607         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
608         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
609         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
610         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
611         vEncSample->WaitForEOS();
612         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
613     }
614 }
615 
616 /**
617  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0170
618  * @tc.name      : h265 surf分层编码过程中强制I帧，检查相邻分层结构是否刷新
619  * @tc.desc      : function test
620  */
621 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0170, TestSize.Level1)
622 {
623     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
624         auto vEncSample = make_unique<VEncAPI11Sample>();
625         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0170.h265";
626         vEncSample->INP_DIR = INP_DIR_720;
627         vEncSample->DEFAULT_WIDTH = 1280;
628         vEncSample->DEFAULT_HEIGHT = 720;
629         vEncSample->DEFAULT_FRAME_RATE = 30;
630         vEncSample->SURF_INPUT = true;
631         vEncSample->TEMPORAL_ENABLE = true;
632         vEncSample->TEMPORAL_CONFIG = true;
633         int32_t temporalGopSize = 3;
634         vEncSample->enableForceIDR = true;
635         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
636         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
637         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
638         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
639         vEncSample->WaitForEOS();
640         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
641     }
642 }
643 
644 /**
645  * @tc.number    : VIDEO_TEMPORAL_ENCODE_FUNCTION_0180
646  * @tc.name      : h265 surf分层编码过程中强制I帧，检查跨帧分层结构是否刷新
647  * @tc.desc      : function test
648  */
649 HWTEST_F(HwEncTemporalNdkTest, VIDEO_TEMPORAL_ENCODE_FUNCTION_0180, TestSize.Level1)
650 {
651     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
652         auto vEncSample = make_unique<VEncAPI11Sample>();
653         vEncSample->OUT_DIR = "/data/test/media/VIDEO_TEMPORAL_ENCODE_FUNCTION_0180.h265";
654         vEncSample->INP_DIR = INP_DIR_720;
655         vEncSample->DEFAULT_WIDTH = 1280;
656         vEncSample->DEFAULT_HEIGHT = 720;
657         vEncSample->DEFAULT_FRAME_RATE = 30;
658         vEncSample->SURF_INPUT = true;
659         vEncSample->TEMPORAL_ENABLE = true;
660         vEncSample->TEMPORAL_CONFIG = true;
661         vEncSample->TEMPORAL_JUMP_MODE = true;
662         int32_t temporalGopSize = 4;
663         vEncSample->enableForceIDR = true;
664         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
665         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
666         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
667         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
668         vEncSample->WaitForEOS();
669         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
670     }
671 }
672 
673 /**
674  * @tc.number    : LTR_FUNC_001
675  * @tc.name      : LTR count设置为非法值
676  * @tc.desc      : function test
677  */
678 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_001, TestSize.Level0)
679 {
680     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
681         auto vEncSample = make_unique<VEncAPI11Sample>();
682         vEncSample->OUT_DIR = "/data/test/media/LTR_FUNC_001.h265";
683         vEncSample->INP_DIR = INP_DIR_720;
684         vEncSample->DEFAULT_WIDTH = 1280;
685         vEncSample->DEFAULT_HEIGHT = 720;
686         vEncSample->DEFAULT_FRAME_RATE = 30;
687         vEncSample->SURF_INPUT = true;
688         vEncSample->ltrParam.enableUseLtr = true;
689         vEncSample->enableLTR = true;
690         vEncSample->ltrParam.ltrCount = 0;
691         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
692         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
693         ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder());
694         ASSERT_EQ(AV_ERR_OK, vEncSample->Reset());
695         vEncSample->ltrParam.ltrCount = 11;
696         ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder());
697     }
698 }
699 
700 /**
701  * @tc.number    : LTR_FUNC_002
702  * @tc.name      : 能力查询是否支持LTR
703  * @tc.desc      : function test
704  */
705 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_002, TestSize.Level0)
706 {
707     OH_AVCapability *capa = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
708     const char* codecName = OH_AVCapability_GetName(capa);
709     if (!strcmp(codecName, "OMX.hisi.video.encoder.hevc")) {
710         ASSERT_EQ(true, OH_AVCapability_IsFeatureSupported(capa, VIDEO_ENCODER_LONG_TERM_REFERENCE));
711     } else {
712         ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capa, VIDEO_ENCODER_LONG_TERM_REFERENCE));
713     }
714 }
715 
716 /**
717  * @tc.number    : LTR_FUNC_004
718  * @tc.name      : h265 surf模式 count 1 ,mark 第5帧 ,后续帧标记use
719  * @tc.desc      : function test
720  */
721 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_004, TestSize.Level0)
722 {
723     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
724         auto vEncSample = make_unique<VEncAPI11Sample>();
725         vEncSample->OUT_DIR = "/data/test/media/LTR_FUNC_004.h265";
726         vEncSample->INP_DIR = INP_DIR_720;
727         vEncSample->DEFAULT_WIDTH = 1280;
728         vEncSample->DEFAULT_HEIGHT = 720;
729         vEncSample->DEFAULT_FRAME_RATE = 30;
730         vEncSample->SURF_INPUT = true;
731         vEncSample->ltrParam.enableUseLtr = true;
732         vEncSample->enableLTR = true;
733         vEncSample->ltrParam.ltrCount = 1;
734         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
735         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
736         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
737         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
738         vEncSample->WaitForEOS();
739         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
740     }
741 }
742 
743 /**
744  * @tc.number    : LTR_FUNC_005
745  * @tc.name      : h265 surf模式 count 1 ,mark 第5帧 ,后续帧标记use 但poc错误
746  * @tc.desc      : function test
747  */
748 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_005, TestSize.Level1)
749 {
750     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
751         auto vEncSample = make_unique<VEncAPI11Sample>();
752         vEncSample->OUT_DIR = "/data/test/media/LTR_FUNC_005.h265";
753         vEncSample->INP_DIR = INP_DIR_720;
754         vEncSample->DEFAULT_WIDTH = 1280;
755         vEncSample->DEFAULT_HEIGHT = 720;
756         vEncSample->DEFAULT_FRAME_RATE = 30;
757         vEncSample->SURF_INPUT = true;
758         vEncSample->ltrParam.enableUseLtr = true;
759         vEncSample->enableLTR = true;
760         vEncSample->ltrParam.useBadLtr = true;
761         vEncSample->ltrParam.ltrCount = 1;
762         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
763         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
764         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
765         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
766         vEncSample->WaitForEOS();
767         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
768     }
769 }
770 
771 /**
772  * @tc.number    : LTR_FUNC_006
773  * @tc.name      : h265 surf模式 count 10 ,每隔5帧mark一帧,每个参考帧后面都正确use当前参考帧
774  * @tc.desc      : function test
775  */
776 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_006, TestSize.Level0)
777 {
778     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
779         auto vEncSample = make_unique<VEncAPI11Sample>();
780         vEncSample->OUT_DIR = "/data/test/media/LTR_FUNC_006.h265";
781         vEncSample->INP_DIR = INP_DIR_720;
782         vEncSample->DEFAULT_WIDTH = 1280;
783         vEncSample->DEFAULT_HEIGHT = 720;
784         vEncSample->DEFAULT_FRAME_RATE = 30;
785         vEncSample->SURF_INPUT = true;
786         vEncSample->ltrParam.enableUseLtr = true;
787         vEncSample->enableLTR = true;
788         vEncSample->ltrParam.ltrCount = 10;
789         vEncSample->ltrParam.ltrInterval = 5;
790         vEncSample->ltrParam.useLtrIndex = 1;
791         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
792         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
793         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
794         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
795         vEncSample->WaitForEOS();
796         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
797     }
798 }
799 
800 /**
801  * @tc.number    : LTR_FUNC_007
802  * @tc.name      : h265 surf模式 count 10 ,每隔5帧mark一帧,不设置use帧
803  * @tc.desc      : function test
804  */
805 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_007, TestSize.Level2)
806 {
807     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
808         auto vEncSample = make_unique<VEncAPI11Sample>();
809         vEncSample->OUT_DIR = "/data/test/media/LTR_FUNC_007.h265";
810         vEncSample->INP_DIR = INP_DIR_720;
811         vEncSample->DEFAULT_WIDTH = 1280;
812         vEncSample->DEFAULT_HEIGHT = 720;
813         vEncSample->DEFAULT_FRAME_RATE = 30;
814         vEncSample->SURF_INPUT = true;
815         vEncSample->ltrParam.enableUseLtr = false;
816         vEncSample->enableLTR = true;
817         vEncSample->ltrParam.ltrCount = 10;
818         vEncSample->ltrParam.ltrInterval = 5;
819         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
820         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
821         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
822         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
823         vEncSample->WaitForEOS();
824         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
825     }
826 }
827 
828 /**
829  * @tc.number    : LTR_FUNC_008
830  * @tc.name      : h265 surf模式 count 2 ,每隔5帧mark一帧,所有帧都use第一个参考帧
831  * @tc.desc      : function test
832  */
833 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_008, TestSize.Level1)
834 {
835     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
836         auto vEncSample = make_unique<VEncAPI11Sample>();
837         vEncSample->OUT_DIR = "/data/test/media/LTR_FUNC_008.h265";
838         vEncSample->INP_DIR = INP_DIR_720;
839         vEncSample->DEFAULT_WIDTH = 1280;
840         vEncSample->DEFAULT_HEIGHT = 720;
841         vEncSample->DEFAULT_FRAME_RATE = 30;
842         vEncSample->SURF_INPUT = true;
843         vEncSample->ltrParam.enableUseLtr = true;
844         vEncSample->enableLTR = true;
845         vEncSample->ltrParam.ltrCount = 2;
846         vEncSample->ltrParam.ltrInterval = 5;
847         vEncSample->ltrParam.useLtrIndex = 0;
848         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
849         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
850         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
851         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
852         vEncSample->WaitForEOS();
853         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
854     }
855 }
856 
857 /**
858  * @tc.number    : LTR_FUNC_009
859  * @tc.name      : h265 surf模式 ,不设置count ,mark一个参考帧 ,一个被标记为use ,poc正确
860  * @tc.desc      : function test
861  */
862 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_009, TestSize.Level2)
863 {
864     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
865         auto vEncSample = make_unique<VEncAPI11Sample>();
866         vEncSample->OUT_DIR = "/data/test/media/LTR_FUNC_009.h265";
867         vEncSample->INP_DIR = INP_DIR_720;
868         vEncSample->DEFAULT_WIDTH = 1280;
869         vEncSample->DEFAULT_HEIGHT = 720;
870         vEncSample->DEFAULT_FRAME_RATE = 30;
871         vEncSample->ltrParam.ltrCount = -1;
872         vEncSample->SURF_INPUT = true;
873         vEncSample->ltrParam.enableUseLtr = true;
874         vEncSample->enableLTR = true;
875         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
876         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
877         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
878         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
879         vEncSample->WaitForEOS();
880         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
881     }
882 }
883 
884 /**
885  * @tc.number    : LTR_FUNC_010
886  * @tc.name      : h265 surf模式,分层编码 和LTR同时设置
887  * @tc.desc      : function test
888  */
889 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_010, TestSize.Level1)
890 {
891     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
892         auto vEncSample = make_unique<VEncAPI11Sample>();
893         vEncSample->OUT_DIR = "/data/test/media/LTR_FUNC_010.h265";
894         vEncSample->INP_DIR = INP_DIR_720;
895         vEncSample->DEFAULT_WIDTH = 1280;
896         vEncSample->DEFAULT_HEIGHT = 720;
897         vEncSample->DEFAULT_FRAME_RATE = 30;
898         vEncSample->SURF_INPUT = true;
899         vEncSample->enableLTR = true;
900         vEncSample->TEMPORAL_ENABLE = true;
901         vEncSample->TEMPORAL_DEFAULT = true;
902         int32_t temporalGopSize = 0;
903         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
904         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
905         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
906         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
907         vEncSample->WaitForEOS();
908         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
909     }
910 }
911 
912 /**
913  * @tc.number    : LTR_FUNC_011
914  * @tc.name      : count为5,h264 buffer,每隔5帧mark参考帧,且都被正确use
915  * @tc.desc      : function test
916  */
917 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_011, TestSize.Level0)
918 {
919     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
920         auto vEncApi11Sample = make_unique<VEncAPI11Sample>();
921         vEncApi11Sample->INP_DIR = INP_DIR_720;
922         vEncApi11Sample->DEFAULT_WIDTH = 1280;
923         vEncApi11Sample->DEFAULT_HEIGHT = 720;
924         vEncApi11Sample->DEFAULT_FRAME_RATE = 30;
925         vEncApi11Sample->DEFAULT_BITRATE_MODE = CBR;
926         vEncApi11Sample->SURF_INPUT = false;
927         vEncApi11Sample->DEFAULT_KEY_FRAME_INTERVAL = -1;
928         vEncApi11Sample->OUT_DIR = "/data/test/media/LTR_FUNC_011.h264";
929         vEncApi11Sample->enableLTR = true;
930         vEncApi11Sample->ltrParam.enableUseLtr = true;
931         vEncApi11Sample->ltrParam.ltrCount = 5;
932         vEncApi11Sample->ltrParam.ltrInterval = 5;
933         vEncApi11Sample->ltrParam.useLtrIndex = 1;
934         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->CreateVideoEncoder(g_codecName));
935         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->SetVideoEncoderCallback());
936         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->ConfigureVideoEncoder());
937         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->StartVideoEncoder());
938         vEncApi11Sample->WaitForEOS();
939         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->errCount);
940     }
941 }
942 
943 /**
944  * @tc.number    : LTR_FUNC_012
945  * @tc.name      : h264 surf模式 每隔5帧mark参考帧
946  * @tc.desc      : function test
947  */
948 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_012, TestSize.Level0)
949 {
950     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
951         auto vEncSample = make_unique<VEncAPI11Sample>();
952         vEncSample->OUT_DIR = "/data/test/media/LTR_FUNC_012.h265";
953         vEncSample->INP_DIR = INP_DIR_720;
954         vEncSample->DEFAULT_WIDTH = 1280;
955         vEncSample->DEFAULT_HEIGHT = 720;
956         vEncSample->DEFAULT_FRAME_RATE = 30;
957         vEncSample->SURF_INPUT = true;
958         vEncSample->enableLTR = true;
959         vEncSample->ltrParam.ltrCount = 5;
960         vEncSample->ltrParam.ltrInterval = 5;
961         vEncSample->ltrParam.enableUseLtr = true;
962         vEncSample->ltrParam.useLtrIndex = 1;
963         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
964         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
965         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
966         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
967         vEncSample->WaitForEOS();
968         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
969     }
970 }
971 
972 /**
973  * @tc.number    : LTR_FUNC_013
974  * @tc.name      : count为5,h265 buffer,每隔5帧mark参考帧,且都被正确use
975  * @tc.desc      : function test
976  */
977 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_013, TestSize.Level0)
978 {
979     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
980         auto vEncApi11Sample = make_unique<VEncAPI11Sample>();
981         vEncApi11Sample->INP_DIR = INP_DIR_720;
982         vEncApi11Sample->DEFAULT_WIDTH = 1280;
983         vEncApi11Sample->DEFAULT_HEIGHT = 720;
984         vEncApi11Sample->DEFAULT_FRAME_RATE = 30;
985         vEncApi11Sample->DEFAULT_BITRATE_MODE = CBR;
986         vEncApi11Sample->SURF_INPUT = false;
987         vEncApi11Sample->DEFAULT_KEY_FRAME_INTERVAL = -1;
988         vEncApi11Sample->OUT_DIR = "/data/test/media/LTR_FUNC_013.h265";
989         vEncApi11Sample->enableLTR = true;
990         vEncApi11Sample->ltrParam.enableUseLtr = true;
991         vEncApi11Sample->ltrParam.ltrCount = 5;
992         vEncApi11Sample->ltrParam.ltrInterval = 5;
993         vEncApi11Sample->ltrParam.useLtrIndex = 1;
994         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->CreateVideoEncoder(g_codecNameHEVC));
995         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->SetVideoEncoderCallback());
996         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->ConfigureVideoEncoder());
997         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->StartVideoEncoder());
998         vEncApi11Sample->WaitForEOS();
999         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->errCount);
1000     }
1001 }
1002 
1003 /**
1004  * @tc.number    : LTR_FUNC_014
1005  * @tc.name      : h265 surf模式 每隔5帧mark参考帧
1006  * @tc.desc      : function test
1007  */
1008 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_014, TestSize.Level0)
1009 {
1010     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1011         auto vEncSample = make_unique<VEncAPI11Sample>();
1012         vEncSample->OUT_DIR = "/data/test/media/LTR_FUNC_014.h265";
1013         vEncSample->INP_DIR = INP_DIR_720;
1014         vEncSample->DEFAULT_WIDTH = 1280;
1015         vEncSample->DEFAULT_HEIGHT = 720;
1016         vEncSample->DEFAULT_FRAME_RATE = 30;
1017         vEncSample->SURF_INPUT = true;
1018         vEncSample->enableLTR = true;
1019         vEncSample->ltrParam.ltrCount = 5;
1020         vEncSample->ltrParam.ltrInterval = 5;
1021         vEncSample->ltrParam.enableUseLtr = true;
1022         vEncSample->ltrParam.useLtrIndex = 1;
1023         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1024         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1025         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1026         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1027         vEncSample->WaitForEOS();
1028         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1029     }
1030 }
1031 
1032 /**
1033  * @tc.number    : LTR_FUNC_015
1034  * @tc.name      : count为5,h264 buffer,每隔5帧mark参考帧,且use自己
1035  * @tc.desc      : function test
1036  */
1037 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_015, TestSize.Level1)
1038 {
1039     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1040         auto vEncApi11Sample = make_unique<VEncAPI11Sample>();
1041         vEncApi11Sample->INP_DIR = INP_DIR_720;
1042         vEncApi11Sample->DEFAULT_WIDTH = 1280;
1043         vEncApi11Sample->DEFAULT_HEIGHT = 720;
1044         vEncApi11Sample->DEFAULT_FRAME_RATE = 30;
1045         vEncApi11Sample->DEFAULT_BITRATE_MODE = CBR;
1046         vEncApi11Sample->SURF_INPUT = false;
1047         vEncApi11Sample->DEFAULT_KEY_FRAME_INTERVAL = -1;
1048         vEncApi11Sample->OUT_DIR = "/data/test/media/LTR_FUNC_015.h264";
1049         vEncApi11Sample->ltrParam.enableUseLtr = true;
1050         vEncApi11Sample->ltrParam.markAndUseSelf = true;
1051         vEncApi11Sample->ltrParam.ltrCount = 5;
1052         vEncApi11Sample->ltrParam.ltrInterval = 5;
1053         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->CreateVideoEncoder(g_codecName));
1054         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->SetVideoEncoderCallback());
1055         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->ConfigureVideoEncoder());
1056         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->StartVideoEncoder());
1057         vEncApi11Sample->WaitForEOS();
1058         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->errCount);
1059     }
1060 }
1061 
1062 /**
1063  * @tc.number    : LTR_FUNC_016
1064  * @tc.name      : count为5,h265 buffer,每隔5帧mark参考帧,且use自己
1065  * @tc.desc      : function test
1066  */
1067 HWTEST_F(HwEncTemporalNdkTest, LTR_FUNC_016, TestSize.Level1)
1068 {
1069     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1070         auto vEncApi11Sample = make_unique<VEncAPI11Sample>();
1071         vEncApi11Sample->INP_DIR = INP_DIR_720;
1072         vEncApi11Sample->DEFAULT_WIDTH = 1280;
1073         vEncApi11Sample->DEFAULT_HEIGHT = 720;
1074         vEncApi11Sample->DEFAULT_FRAME_RATE = 30;
1075         vEncApi11Sample->DEFAULT_BITRATE_MODE = CBR;
1076         vEncApi11Sample->SURF_INPUT = false;
1077         vEncApi11Sample->DEFAULT_KEY_FRAME_INTERVAL = -1;
1078         vEncApi11Sample->OUT_DIR = "/data/test/media/LTR_FUNC_016.h265";
1079         vEncApi11Sample->ltrParam.enableUseLtr = true;
1080         vEncApi11Sample->ltrParam.markAndUseSelf = true;
1081         vEncApi11Sample->ltrParam.ltrCount = 5;
1082         vEncApi11Sample->ltrParam.ltrInterval = 5;
1083         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->CreateVideoEncoder(g_codecNameHEVC));
1084         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->SetVideoEncoderCallback());
1085         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->ConfigureVideoEncoder());
1086         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->StartVideoEncoder());
1087         vEncApi11Sample->WaitForEOS();
1088         ASSERT_EQ(AV_ERR_OK, vEncApi11Sample->errCount);
1089     }
1090 }
1091 
1092 /**
1093  * @tc.number    : VIDEO_UNIFORMLY_ENCODE_FUNCTION_0100
1094  * @tc.name      : uniformly temporal buffer 264 encode,tgop 2
1095  * @tc.desc      : func test
1096  */
1097 HWTEST_F(HwEncTemporalNdkTest, VIDEO_UNIFORMLY_ENCODE_FUNCTION_0100, TestSize.Level0)
1098 {
1099     auto vEncSample = make_unique<VEncAPI11Sample>();
1100     vEncSample->OUT_DIR = "/data/test/media/VIDEO_UNIFORMLY_ENCODE_FUNCTION_0100.h264";
1101     vEncSample->INP_DIR = INP_DIR_720;
1102     vEncSample->DEFAULT_WIDTH = 1280;
1103     vEncSample->DEFAULT_HEIGHT = 720;
1104     vEncSample->DEFAULT_FRAME_RATE = 30;
1105     vEncSample->SURF_INPUT = false;
1106     vEncSample->TEMPORAL_ENABLE = true;
1107     vEncSample->TEMPORAL_UNIFORMLY = true;
1108     int32_t temporalGopSize = 2;
1109     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1110     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1111     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
1112     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1113     vEncSample->WaitForEOS();
1114     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1115 }
1116 
1117 /**
1118  * @tc.number    : VIDEO_UNIFORMLY_ENCODE_FUNCTION_0200
1119  * @tc.name      : uniformly temporal buffer 264 encode,tgop 3
1120  * @tc.desc      : func test
1121  */
1122 HWTEST_F(HwEncTemporalNdkTest, VIDEO_UNIFORMLY_ENCODE_FUNCTION_0200, TestSize.Level1)
1123 {
1124     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1125         auto vEncSample = make_unique<VEncAPI11Sample>();
1126         vEncSample->OUT_DIR = "/data/test/media/VIDEO_UNIFORMLY_ENCODE_FUNCTION_0200.h264";
1127         vEncSample->INP_DIR = INP_DIR_720;
1128         vEncSample->DEFAULT_WIDTH = 1280;
1129         vEncSample->DEFAULT_HEIGHT = 720;
1130         vEncSample->DEFAULT_FRAME_RATE = 30;
1131         vEncSample->SURF_INPUT = false;
1132         vEncSample->TEMPORAL_ENABLE = true;
1133         vEncSample->TEMPORAL_UNIFORMLY = true;
1134         int32_t temporalGopSize = 3;
1135         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1136         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1137         ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
1138     }
1139 }
1140 
1141 /**
1142  * @tc.number    : VIDEO_UNIFORMLY_ENCODE_FUNCTION_0300
1143  * @tc.name      : uniformly temporal buffer 265 encode,tgop 2
1144  * @tc.desc      : func test
1145  */
1146 HWTEST_F(HwEncTemporalNdkTest, VIDEO_UNIFORMLY_ENCODE_FUNCTION_0300, TestSize.Level1)
1147 {
1148     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1149         auto vEncSample = make_unique<VEncAPI11Sample>();
1150         vEncSample->OUT_DIR = "/data/test/media/VIDEO_UNIFORMLY_ENCODE_FUNCTION_0300.h265";
1151         vEncSample->INP_DIR = INP_DIR_720;
1152         vEncSample->DEFAULT_WIDTH = 1280;
1153         vEncSample->DEFAULT_HEIGHT = 720;
1154         vEncSample->DEFAULT_FRAME_RATE = 30;
1155         vEncSample->SURF_INPUT = false;
1156         vEncSample->TEMPORAL_ENABLE = true;
1157         vEncSample->TEMPORAL_UNIFORMLY = true;
1158         int32_t temporalGopSize = 2;
1159         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1160         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1161         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
1162         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1163         vEncSample->WaitForEOS();
1164         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1165     }
1166 }
1167 
1168 /**
1169  * @tc.number    : VIDEO_UNIFORMLY_ENCODE_FUNCTION_0400
1170  * @tc.name      : uniformly temporal buffer 265 encode,tgop 4
1171  * @tc.desc      : func test
1172  */
1173 HWTEST_F(HwEncTemporalNdkTest, VIDEO_UNIFORMLY_ENCODE_FUNCTION_0400, TestSize.Level1)
1174 {
1175     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1176         auto vEncSample = make_unique<VEncAPI11Sample>();
1177         vEncSample->OUT_DIR = "/data/test/media/VIDEO_UNIFORMLY_ENCODE_FUNCTION_0400.h265";
1178         vEncSample->INP_DIR = INP_DIR_720;
1179         vEncSample->DEFAULT_WIDTH = 1280;
1180         vEncSample->DEFAULT_HEIGHT = 720;
1181         vEncSample->DEFAULT_FRAME_RATE = 30;
1182         vEncSample->SURF_INPUT = false;
1183         vEncSample->TEMPORAL_ENABLE = true;
1184         vEncSample->TEMPORAL_UNIFORMLY = true;
1185         int32_t temporalGopSize = 4;
1186         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1187         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1188         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
1189         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1190         vEncSample->WaitForEOS();
1191         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1192     }
1193 }
1194 
1195 /**
1196  * @tc.number    : VIDEO_UNIFORMLY_ENCODE_FUNCTION_0500
1197  * @tc.name      : uniformly temporal buffer 265 encode,tgop 5
1198  * @tc.desc      : func test
1199  */
1200 HWTEST_F(HwEncTemporalNdkTest, VIDEO_UNIFORMLY_ENCODE_FUNCTION_0500, TestSize.Level1)
1201 {
1202     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1203         auto vEncSample = make_unique<VEncAPI11Sample>();
1204         vEncSample->OUT_DIR = "/data/test/media/VIDEO_UNIFORMLY_ENCODE_FUNCTION_0500.h265";
1205         vEncSample->INP_DIR = INP_DIR_720;
1206         vEncSample->DEFAULT_WIDTH = 1280;
1207         vEncSample->DEFAULT_HEIGHT = 720;
1208         vEncSample->DEFAULT_FRAME_RATE = 30;
1209         vEncSample->SURF_INPUT = false;
1210         vEncSample->TEMPORAL_ENABLE = true;
1211         vEncSample->TEMPORAL_UNIFORMLY = true;
1212         int32_t temporalGopSize = 5;
1213         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1214         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1215         ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
1216     }
1217 }
1218 
1219 /**
1220  * @tc.number    : VIDEO_UNIFORMLY_ENCODE_FUNCTION_0600
1221  * @tc.name      : uniformly temporal surface 264 encode,tgop 2
1222  * @tc.desc      : func test
1223  */
1224 HWTEST_F(HwEncTemporalNdkTest, VIDEO_UNIFORMLY_ENCODE_FUNCTION_0600, TestSize.Level0)
1225 {
1226     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1227         auto vEncSample = make_unique<VEncAPI11Sample>();
1228         vEncSample->OUT_DIR = "/data/test/media/VIDEO_UNIFORMLY_ENCODE_FUNCTION_0600.h264";
1229         vEncSample->INP_DIR = INP_DIR_720;
1230         vEncSample->DEFAULT_WIDTH = 1280;
1231         vEncSample->DEFAULT_HEIGHT = 720;
1232         vEncSample->DEFAULT_FRAME_RATE = 30;
1233         vEncSample->SURF_INPUT = true;
1234         vEncSample->TEMPORAL_ENABLE = true;
1235         vEncSample->TEMPORAL_UNIFORMLY = true;
1236         int32_t temporalGopSize = 2;
1237         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1238         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1239         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
1240         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1241         vEncSample->WaitForEOS();
1242         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1243     }
1244 }
1245 
1246 /**
1247  * @tc.number    : VIDEO_UNIFORMLY_ENCODE_FUNCTION_0700
1248  * @tc.name      : uniformly temporal surface 264 encode,tgop 3
1249  * @tc.desc      : func test
1250  */
1251 HWTEST_F(HwEncTemporalNdkTest, VIDEO_UNIFORMLY_ENCODE_FUNCTION_0700, TestSize.Level1)
1252 {
1253     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1254         auto vEncSample = make_unique<VEncAPI11Sample>();
1255         vEncSample->OUT_DIR = "/data/test/media/VIDEO_UNIFORMLY_ENCODE_FUNCTION_0700.h264";
1256         vEncSample->INP_DIR = INP_DIR_720;
1257         vEncSample->DEFAULT_WIDTH = 1280;
1258         vEncSample->DEFAULT_HEIGHT = 720;
1259         vEncSample->DEFAULT_FRAME_RATE = 30;
1260         vEncSample->SURF_INPUT = true;
1261         vEncSample->TEMPORAL_ENABLE = true;
1262         vEncSample->TEMPORAL_UNIFORMLY = true;
1263         int32_t temporalGopSize = 3;
1264         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1265         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1266         ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
1267     }
1268 }
1269 
1270 /**
1271  * @tc.number    : VIDEO_UNIFORMLY_ENCODE_FUNCTION_0800
1272  * @tc.name      : uniformly temporal surface 265 encode,tgop 2
1273  * @tc.desc      : func test
1274  */
1275 HWTEST_F(HwEncTemporalNdkTest, VIDEO_UNIFORMLY_ENCODE_FUNCTION_0800, TestSize.Level1)
1276 {
1277     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1278         auto vEncSample = make_unique<VEncAPI11Sample>();
1279         vEncSample->OUT_DIR = "/data/test/media/VIDEO_UNIFORMLY_ENCODE_FUNCTION_0800.h265";
1280         vEncSample->INP_DIR = INP_DIR_720;
1281         vEncSample->DEFAULT_WIDTH = 1280;
1282         vEncSample->DEFAULT_HEIGHT = 720;
1283         vEncSample->DEFAULT_FRAME_RATE = 30;
1284         vEncSample->SURF_INPUT = true;
1285         vEncSample->TEMPORAL_ENABLE = true;
1286         vEncSample->TEMPORAL_UNIFORMLY = true;
1287         int32_t temporalGopSize = 2;
1288         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1289         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1290         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
1291         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1292         vEncSample->WaitForEOS();
1293         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1294     }
1295 }
1296 
1297 /**
1298  * @tc.number    : VIDEO_UNIFORMLY_ENCODE_FUNCTION_0900
1299  * @tc.name      : uniformly temporal surface 265 encode,tgop 4
1300  * @tc.desc      : func test
1301  */
1302 HWTEST_F(HwEncTemporalNdkTest, VIDEO_UNIFORMLY_ENCODE_FUNCTION_0900, TestSize.Level1)
1303 {
1304     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1305         auto vEncSample = make_unique<VEncAPI11Sample>();
1306         vEncSample->OUT_DIR = "/data/test/media/VIDEO_UNIFORMLY_ENCODE_FUNCTION_0900.h265";
1307         vEncSample->INP_DIR = INP_DIR_720;
1308         vEncSample->DEFAULT_WIDTH = 1280;
1309         vEncSample->DEFAULT_HEIGHT = 720;
1310         vEncSample->DEFAULT_FRAME_RATE = 30;
1311         vEncSample->SURF_INPUT = true;
1312         vEncSample->TEMPORAL_ENABLE = true;
1313         vEncSample->TEMPORAL_UNIFORMLY = true;
1314         int32_t temporalGopSize = 4;
1315         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1316         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1317         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
1318         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1319         vEncSample->WaitForEOS();
1320         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1321     }
1322 }
1323 
1324 /**
1325  * @tc.number    : VIDEO_UNIFORMLY_ENCODE_FUNCTION_1000
1326  * @tc.name      : uniformly temporal buffer 265 encode,tgop 5
1327  * @tc.desc      : func test
1328  */
1329 HWTEST_F(HwEncTemporalNdkTest, VIDEO_UNIFORMLY_ENCODE_FUNCTION_1000, TestSize.Level1)
1330 {
1331     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1332         auto vEncSample = make_unique<VEncAPI11Sample>();
1333         vEncSample->OUT_DIR = "/data/test/media/VIDEO_UNIFORMLY_ENCODE_FUNCTION_1000.h265";
1334         vEncSample->INP_DIR = INP_DIR_720;
1335         vEncSample->DEFAULT_WIDTH = 1280;
1336         vEncSample->DEFAULT_HEIGHT = 720;
1337         vEncSample->DEFAULT_FRAME_RATE = 30;
1338         vEncSample->SURF_INPUT = true;
1339         vEncSample->TEMPORAL_ENABLE = true;
1340         vEncSample->TEMPORAL_UNIFORMLY = true;
1341         int32_t temporalGopSize = 5;
1342         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1343         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1344         ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
1345     }
1346 }
1347 } // namespace