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