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