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