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 <unistd.h>
16 #include <fstream>
17 #include <gtest/gtest.h>
18
19 #include "native_avformat.h"
20 #include "surface/window.h"
21 #include "external_window.h"
22
23 #include "video_processing.h"
24 #include "video_processing_impl.h"
25 #include "video_processing_loader.h"
26 #include "video_processing_native.h"
27 #include "video_processing_types.h"
28 #include "video_processing_callback_impl.h"
29 #include "video_processing_callback_native.h"
30 #include "video_sample.h"
31 #ifdef SKIA_ENABLE
32 #include "skia_impl.h"
33 #endif
34 #include "detail_enhancer_video_native.h"
35
36 constexpr int64_t NANOS_IN_SECOND = 1000000000L;
37 constexpr int64_t NANOS_IN_MICRO = 1000L;
38 constexpr uint32_t DEFAULT_WIDTH = 1920;
39 constexpr uint32_t DEFAULT_HEIGHT = 1080;
40 constexpr uint64_t NV12_FMT_INDEX = 24;
41 constexpr int CREATE_TYPE = 0x4;
42
43 using namespace std;
44 using namespace testing::ext;
45
46 namespace OHOS {
47 namespace Media {
48 namespace VideoProcessingEngine {
49
50 const VideoProcessing_ColorSpaceInfo SRC_INFO {
51 .metadataType = OH_VIDEO_HDR_HDR10,
52 .colorSpace = OH_COLORSPACE_BT2020_PQ_LIMIT,
53 .pixelFormat = NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP,
54 };
55
56 const VideoProcessing_ColorSpaceInfo DST_INFO {
57 .metadataType = OH_VIDEO_HDR_HLG,
58 .colorSpace = OH_COLORSPACE_BT2020_PQ_LIMIT,
59 .pixelFormat = NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP,
60 };
61
62 BufferRequestConfig bufferConfig1 = {
63 .width = 0,
64 .height = 0,
65 .strideAlignment = 0x8,
66 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
67 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
68 .timeout = 0,
69 };
70
71 BufferRequestConfig bufferConfig2 = {
72 .width = 400,
73 .height = 0,
74 .strideAlignment = 0x8,
75 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
76 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
77 .timeout = 0,
78 };
79
80 BufferRequestConfig bufferConfig4 = {
81 .width = 0,
82 .height = 400,
83 .strideAlignment = 0x8,
84 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
85 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
86 .timeout = 0,
87 };
88
89 BufferRequestConfig bufferConfig3 = {
90 .width = 400,
91 .height = 400,
92 .strideAlignment = 0x8,
93 .format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888,
94 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
95 .timeout = 0,
96 };
97
98 static std::condition_variable g_Cond;
99
100 class TestConsumerListener : public IBufferConsumerListener {
101 public:
102 TestConsumerListener(sptr<Surface> cs, std::string_view name);
103 ~TestConsumerListener();
104 void OnBufferAvailable() override;
105 };
106
TestConsumerListener(sptr<Surface> cs,std::string_view name)107 TestConsumerListener::TestConsumerListener(sptr<Surface> cs, std::string_view name) {}
108
~TestConsumerListener()109 TestConsumerListener::~TestConsumerListener() {}
110
OnBufferAvailable()111 void TestConsumerListener::OnBufferAvailable() {}
112
OnErrorEmptyCallback(OH_VideoProcessing * handle,VideoProcessing_ErrorCode errorCode,void * userData)113 void OnErrorEmptyCallback(OH_VideoProcessing* handle, VideoProcessing_ErrorCode errorCode, void* userData)
114 {
115 }
116
OnError(OH_VideoProcessing * handle,VideoProcessing_ErrorCode errorCode,void * userData)117 void OnError(OH_VideoProcessing* handle, VideoProcessing_ErrorCode errorCode, void* userData)
118 {
119 }
120
OnState(OH_VideoProcessing * instance,VideoProcessing_State state,void * userData)121 void OnState(OH_VideoProcessing* instance, VideoProcessing_State state, void* userData)
122 {
123 }
124
OnNewOutputBuffer(OH_VideoProcessing * instance,uint32_t index,void * userData)125 void OnNewOutputBuffer(OH_VideoProcessing* instance, uint32_t index, void* userData)
126 {
127 }
128
129 class DetailEnhancerVideoNdkUnitTest : public testing::Test {
130 public:
131 static void SetUpTestCase(void);
132 static void TearDownTestCase(void);
133 void SetUp();
134 void TearDown();
135 uint32_t FlushSurf(OHNativeWindowBuffer* ohNativeWindowBuffer, OHNativeWindow* window);
136 };
137
SetUpTestCase(void)138 void DetailEnhancerVideoNdkUnitTest::SetUpTestCase(void)
139 {
140 }
141
TearDownTestCase(void)142 void DetailEnhancerVideoNdkUnitTest::TearDownTestCase(void)
143 {
144 }
145
SetUp(void)146 void DetailEnhancerVideoNdkUnitTest::SetUp(void)
147 {
148 }
149
TearDown(void)150 void DetailEnhancerVideoNdkUnitTest::TearDown(void)
151 {
152 }
153
GetSystemTime()154 int64_t GetSystemTime()
155 {
156 struct timespec now;
157 (void)clock_gettime(CLOCK_BOOTTIME, &now);
158 int64_t nanoTime = reinterpret_cast<int64_t>(now.tv_sec) * NANOS_IN_SECOND + now.tv_nsec;
159 return nanoTime / NANOS_IN_MICRO;
160 }
161
FlushSurf(OHNativeWindowBuffer * ohNativeWindowBuffer,OHNativeWindow * window)162 uint32_t DetailEnhancerVideoNdkUnitTest::FlushSurf(OHNativeWindowBuffer* ohNativeWindowBuffer, OHNativeWindow* window)
163 {
164 struct Region region;
165 struct Region::Rect *rect = new Region::Rect();
166 rect->x = 0;
167 rect->y = 0;
168 rect->w = DEFAULT_WIDTH;
169 rect->h = DEFAULT_HEIGHT;
170 region.rects = rect;
171 NativeWindowHandleOpt(window, SET_UI_TIMESTAMP, GetSystemTime());
172 int32_t err = OH_NativeWindow_NativeWindowFlushBuffer(window, ohNativeWindowBuffer, -1, region);
173 delete rect;
174 if (err != 0) {
175 cout << "FlushBuffer failed" << endl;
176 return 1;
177 }
178 return 0;
179 }
180
181 // load test
182 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_00, TestSize.Level1)
183 {
184 VideoProcessingNdkLoader& ndkLoader = VideoProcessingNdkLoader::Get();
185 ndkLoader.LoadLibrary();
186 ndkLoader.LoadLibrary();
187 ndkLoader.InitializeEnvironment();
188 ndkLoader.DeinitializeEnvironment();
189 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
190 OH_VideoProcessing* instance = nullptr;
191 ret = OH_VideoProcessing_Create(&instance, CREATE_TYPE);
192 ndkLoader.Create(&instance, CREATE_TYPE);
193 ndkLoader.LoadLibraryLocked();
194 VideoProcessing_Callback* callback = nullptr;
195 OH_VideoProcessingCallback_Create(&callback);
196 ndkLoader.RegisterCallback(instance, callback, nullptr);
197 OHNativeWindow* window = nullptr;
198 ndkLoader.GetSurface(nullptr, nullptr);
199 ndkLoader.SetSurface(instance, window);
200 ndkLoader.GetSurface(instance, &window);
201 OH_AVFormat* parameter = nullptr;
202 ndkLoader.SetParameter(instance, parameter);
203 ndkLoader.GetParameter(instance, parameter);
204 ndkLoader.Start(instance);
205 ndkLoader.Stop(instance);
206 ndkLoader.RenderOutputBuffer(instance, 0);
207 ndkLoader.Create(&callback);
208 ndkLoader.Destroy(callback);
209 ndkLoader.Destroy(instance);
210 ndkLoader.UnloadLibrary();
211 ndkLoader.UnloadLibrary();
212 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
213 }
214
215 // initialize context with nullptr
216 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_01, TestSize.Level1)
217 {
218 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
219 OH_VideoProcessing* instance = nullptr;
220 ret = OH_VideoProcessing_Create(&instance, CREATE_TYPE);
221 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
222 ret = OH_VideoProcessing_Destroy(instance);
223 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
224 ret = OH_VideoProcessing_DeinitializeEnvironment();
225 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
226 }
227
228 // initialize context with nullptr impl
229 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_01_1, TestSize.Level1)
230 {
231 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
232 OH_VideoProcessing* instance = nullptr;
233 ret = OH_VideoProcessing::Create(&instance, CREATE_TYPE);
234 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
235 ret = OH_VideoProcessing::Destroy(instance);
236 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
237 ret = OH_VideoProcessing_DeinitializeEnvironment();
238 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
239 }
240
241 // create context without initialization
242 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_02, TestSize.Level1)
243 {
244 OH_VideoProcessing* instance = nullptr;
245 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&instance, CREATE_TYPE);
246 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
247 ret = OH_VideoProcessing_Destroy(instance);
248 }
249
250 // create context impl
251 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_02_1, TestSize.Level1)
252 {
253 OH_VideoProcessing* instance = nullptr;
254 VideoProcessing_ErrorCode ret = OH_VideoProcessing::Create(&instance, CREATE_TYPE);
255 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
256 ret = OH_VideoProcessing::Destroy(instance);
257 }
258
259 // initialize context with wrong type impl
260 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_03_1, TestSize.Level1)
261 {
262 int badCreateType = 0x1;
263 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
264 OH_VideoProcessing* instance = nullptr;
265 ret = OH_VideoProcessing::Create(&instance, badCreateType);
266 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
267 ret = OH_VideoProcessing::Destroy(instance);
268 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
269 ret = OH_VideoProcessing_DeinitializeEnvironment();
270 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
271 }
272
273 // destroy context without create
274 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_05, TestSize.Level1)
275 {
276 OH_VideoProcessing_InitializeEnvironment();
277 OH_VideoProcessing* instance = nullptr;
278 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Destroy(instance);
279 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
280 OH_VideoProcessing_DeinitializeEnvironment();
281 }
282
283 // destroy context without create impl
284 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_05_1, TestSize.Level1)
285 {
286 OH_VideoProcessing_InitializeEnvironment();
287 OH_VideoProcessing* instance = nullptr;
288 VideoProcessing_ErrorCode ret = OH_VideoProcessing::Destroy(instance);
289 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
290 OH_VideoProcessing_DeinitializeEnvironment();
291 }
292
293 // destroy context without create or initialize
294 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_06, TestSize.Level1)
295 {
296 OH_VideoProcessing* instance = nullptr;
297 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Destroy(instance);
298 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
299 }
300
301 // destroy context without create or initialize impl
302 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_06_1, TestSize.Level1)
303 {
304 OH_VideoProcessing* instance = nullptr;
305 VideoProcessing_ErrorCode ret = OH_VideoProcessing::Destroy(instance);
306 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
307 }
308
309 // support check with null
310 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_07, TestSize.Level1)
311 {
312 OH_VideoProcessing_InitializeEnvironment();
313 bool res = OH_VideoProcessing_IsColorSpaceConversionSupported(nullptr, nullptr);
314 ASSERT_FALSE(res);
315 OH_VideoProcessing_DeinitializeEnvironment();
316 }
317
318 // support check
319 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_08, TestSize.Level1)
320 {
321 OH_VideoProcessing_InitializeEnvironment();
322 bool res = OH_VideoProcessing_IsColorSpaceConversionSupported(&SRC_INFO, &DST_INFO);
323 ASSERT_FALSE(res);
324 OH_VideoProcessing_DeinitializeEnvironment();
325 }
326
327 // support check 2
328 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_09, TestSize.Level1)
329 {
330 OH_VideoProcessing_InitializeEnvironment();
331 bool res = OH_VideoProcessing_IsColorSpaceConversionSupported(&SRC_INFO, nullptr);
332 ASSERT_FALSE(res);
333 OH_VideoProcessing_DeinitializeEnvironment();
334 }
335
336 // support check 3
337 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_10, TestSize.Level1)
338 {
339 OH_VideoProcessing_InitializeEnvironment();
340 bool res = OH_VideoProcessing_IsColorSpaceConversionSupported(nullptr, &DST_INFO);
341 ASSERT_FALSE(res);
342 OH_VideoProcessing_DeinitializeEnvironment();
343 }
344
345 // metagen check
346 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_11, TestSize.Level1)
347 {
348 OH_VideoProcessing_InitializeEnvironment();
349 bool ret = OH_VideoProcessing_IsMetadataGenerationSupported(nullptr);
350 ASSERT_FALSE(ret);
351 OH_VideoProcessing_DeinitializeEnvironment();
352 }
353
354 // metagen check 2
355 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_12, TestSize.Level1)
356 {
357 OH_VideoProcessing_InitializeEnvironment();
358 bool ret = OH_VideoProcessing_IsMetadataGenerationSupported(&SRC_INFO);
359 ASSERT_FALSE(ret);
360 OH_VideoProcessing_DeinitializeEnvironment();
361 }
362
363 // metagen check 3
364 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_13, TestSize.Level1)
365 {
366 OH_VideoProcessing_InitializeEnvironment();
367 bool ret = OH_VideoProcessing_IsMetadataGenerationSupported(&DST_INFO);
368 ASSERT_FALSE(ret);
369 OH_VideoProcessing_DeinitializeEnvironment();
370 }
371
372 // set parameter to nullptr
373 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_14, TestSize.Level1)
374 {
375 OH_VideoProcessing_InitializeEnvironment();
376 OH_VideoProcessing* instance = nullptr;
377 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
378 OH_AVFormat* parameter = nullptr;
379 VideoProcessing_ErrorCode ret = OH_VideoProcessing_SetParameter(instance, parameter);
380 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
381 OH_VideoProcessing_Destroy(instance);
382 OH_VideoProcessing_DeinitializeEnvironment();
383 }
384
385 // set parameter to nullptr impl
386 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_14_1, TestSize.Level1)
387 {
388 OH_VideoProcessing_InitializeEnvironment();
389 OH_VideoProcessing* instance = nullptr;
390 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
391 OH_AVFormat* parameter = nullptr;
392 VideoProcessing_ErrorCode ret = instance->GetObj()->SetParameter(parameter);
393 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
394 OH_VideoProcessing::Destroy(instance);
395 OH_VideoProcessing_DeinitializeEnvironment();
396 }
397
398 // set parameter quality level to high
399 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_15, TestSize.Level1)
400 {
401 OH_VideoProcessing_InitializeEnvironment();
402 OH_VideoProcessing* instance = nullptr;
403 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
404 OH_AVFormat* parameter = OH_AVFormat_Create();
405 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
406 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
407 VideoProcessing_ErrorCode ret = OH_VideoProcessing_SetParameter(instance, parameter);
408 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
409 OH_VideoProcessing_Destroy(instance);
410 OH_VideoProcessing_DeinitializeEnvironment();
411 }
412
413 // set parameter quality level to high impl
414 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_15_1, TestSize.Level1)
415 {
416 OH_VideoProcessing_InitializeEnvironment();
417 OH_VideoProcessing* instance = nullptr;
418 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
419 OH_AVFormat* parameter = OH_AVFormat_Create();
420 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
421 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
422 VideoProcessing_ErrorCode ret = instance->GetObj()->SetParameter(parameter);
423 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
424 OH_VideoProcessing::Destroy(instance);
425 OH_VideoProcessing_DeinitializeEnvironment();
426 }
427
428 // set parameter quality level to medium
429 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_16, TestSize.Level1)
430 {
431 OH_VideoProcessing_InitializeEnvironment();
432 OH_VideoProcessing* instance = nullptr;
433 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
434 OH_AVFormat* parameter = OH_AVFormat_Create();
435 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
436 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_MEDIUM);
437 VideoProcessing_ErrorCode ret = OH_VideoProcessing_SetParameter(instance, parameter);
438 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
439 OH_VideoProcessing_Destroy(instance);
440 OH_VideoProcessing_DeinitializeEnvironment();
441 }
442
443 // set parameter quality level to medium impl
444 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_16_1, TestSize.Level1)
445 {
446 OH_VideoProcessing_InitializeEnvironment();
447 OH_VideoProcessing* instance = nullptr;
448 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
449 OH_AVFormat* parameter = OH_AVFormat_Create();
450 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
451 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_MEDIUM);
452 VideoProcessing_ErrorCode ret = instance->GetObj()->SetParameter(parameter);
453 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
454 OH_VideoProcessing::Destroy(instance);
455 OH_VideoProcessing_DeinitializeEnvironment();
456 }
457
458 // set parameter quality level to low
459 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_17, TestSize.Level1)
460 {
461 OH_VideoProcessing_InitializeEnvironment();
462 OH_VideoProcessing* instance = nullptr;
463 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
464 OH_AVFormat* parameter = OH_AVFormat_Create();
465 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
466 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_LOW);
467 VideoProcessing_ErrorCode ret = OH_VideoProcessing_SetParameter(instance, parameter);
468 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
469 OH_VideoProcessing_Destroy(instance);
470 OH_VideoProcessing_DeinitializeEnvironment();
471 }
472
473 // set parameter quality level to low impl
474 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_17_1, TestSize.Level1)
475 {
476 OH_VideoProcessing_InitializeEnvironment();
477 OH_VideoProcessing* instance = nullptr;
478 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
479 OH_AVFormat* parameter = OH_AVFormat_Create();
480 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
481 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_LOW);
482 VideoProcessing_ErrorCode ret = instance->GetObj()->SetParameter(parameter);
483 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
484 OH_VideoProcessing::Destroy(instance);
485 OH_VideoProcessing_DeinitializeEnvironment();
486 }
487
488 // set parameter quality level to none
489 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_18, TestSize.Level1)
490 {
491 OH_VideoProcessing_InitializeEnvironment();
492 OH_VideoProcessing* instance = nullptr;
493 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
494 OH_AVFormat* parameter = OH_AVFormat_Create();
495 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
496 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_NONE);
497 VideoProcessing_ErrorCode ret = OH_VideoProcessing_SetParameter(instance, parameter);
498 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
499 OH_VideoProcessing_Destroy(instance);
500 OH_VideoProcessing_DeinitializeEnvironment();
501 }
502
503 // set parameter quality level to none impl
504 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_18_1, TestSize.Level1)
505 {
506 OH_VideoProcessing_InitializeEnvironment();
507 OH_VideoProcessing* instance = nullptr;
508 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
509 OH_AVFormat* parameter = OH_AVFormat_Create();
510 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
511 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_NONE);
512 VideoProcessing_ErrorCode ret = instance->GetObj()->SetParameter(parameter);
513 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
514 OH_VideoProcessing::Destroy(instance);
515 OH_VideoProcessing_DeinitializeEnvironment();
516 }
517
518 // get parameter to non-nullptr impl
519 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_19_1, TestSize.Level1)
520 {
521 OH_VideoProcessing_InitializeEnvironment();
522 OH_VideoProcessing* instance = nullptr;
523 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
524 OH_AVFormat* parameter = OH_AVFormat_Create();
525 VideoProcessing_ErrorCode ret = instance->GetObj()->GetParameter(parameter);
526 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
527 OH_VideoProcessing::Destroy(instance);
528 OH_VideoProcessing_DeinitializeEnvironment();
529 }
530
531 // get parameter to nullptr
532 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_20, TestSize.Level1)
533 {
534 OH_VideoProcessing_InitializeEnvironment();
535 OH_VideoProcessing* instance = nullptr;
536 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
537 OH_AVFormat* parameter = nullptr;
538 VideoProcessing_ErrorCode ret = OH_VideoProcessing_GetParameter(instance, parameter);
539 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
540 OH_VideoProcessing_Destroy(instance);
541 OH_VideoProcessing_DeinitializeEnvironment();
542 }
543
544 // get parameter to nullptr impl
545 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_20_1, TestSize.Level1)
546 {
547 OH_VideoProcessing_InitializeEnvironment();
548 OH_VideoProcessing* instance = nullptr;
549 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
550 OH_AVFormat* parameter = nullptr;
551 VideoProcessing_ErrorCode ret = instance->GetObj()->GetParameter(parameter);
552 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
553 OH_VideoProcessing::Destroy(instance);
554 OH_VideoProcessing_DeinitializeEnvironment();
555 }
556
557 // get parameter after setting to high
558 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_21, TestSize.Level1)
559 {
560 OH_VideoProcessing_InitializeEnvironment();
561 OH_VideoProcessing* instance = nullptr;
562 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
563 OH_AVFormat* parameterSetted = OH_AVFormat_Create();
564 OH_AVFormat_SetIntValue(parameterSetted, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
565 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
566 OH_VideoProcessing_SetParameter(instance, parameterSetted);
567 OH_AVFormat* parameterGot = OH_AVFormat_Create();
568 VideoProcessing_ErrorCode ret = OH_VideoProcessing_GetParameter(instance, parameterGot);
569 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
570 OH_VideoProcessing_Destroy(instance);
571 OH_VideoProcessing_DeinitializeEnvironment();
572 }
573
574 // get parameter after setting to high impl
575 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_21_1, TestSize.Level1)
576 {
577 OH_VideoProcessing_InitializeEnvironment();
578 OH_VideoProcessing* instance = nullptr;
579 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
580 OH_AVFormat* parameterSetted = OH_AVFormat_Create();
581 OH_AVFormat_SetIntValue(parameterSetted, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
582 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
583 instance->GetObj()->SetParameter(parameterSetted);
584 OH_AVFormat* parameterGot = OH_AVFormat_Create();
585 VideoProcessing_ErrorCode ret = instance->GetObj()->GetParameter(parameterGot);
586 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
587 OH_VideoProcessing::Destroy(instance);
588 OH_VideoProcessing_DeinitializeEnvironment();
589 }
590
591 // set surface with surface from another instance
592 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_22, TestSize.Level1)
593 {
594 OH_VideoProcessing_InitializeEnvironment();
595 OH_VideoProcessing* instance = nullptr;
596 OH_VideoProcessing* instance2 = nullptr;
597 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
598 OH_VideoProcessing_Create(&instance2, CREATE_TYPE);
599 OHNativeWindow* window = nullptr;
600 OHNativeWindow* window2 = nullptr;
601 OH_VideoProcessing_GetSurface(instance, &window);
602 OH_VideoProcessing_GetSurface(instance2, &window2);
603 VideoProcessing_ErrorCode ret = OH_VideoProcessing_SetSurface(instance, window2);
604 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
605 OH_VideoProcessing_Destroy(instance);
606 OH_VideoProcessing_DeinitializeEnvironment();
607 }
608
609 // set surface with surface from another instance impl
610 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_22_1, TestSize.Level1)
611 {
612 OH_VideoProcessing_InitializeEnvironment();
613 OH_VideoProcessing* instance = nullptr;
614 OH_VideoProcessing* instance2 = nullptr;
615 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
616 OH_VideoProcessing::Create(&instance2, CREATE_TYPE);
617 OHNativeWindow* window = nullptr;
618 OHNativeWindow* window2 = nullptr;
619 instance->GetObj()->GetSurface(&window);
620 instance->GetObj()->GetSurface(&window2);
621 VideoProcessing_ErrorCode ret = instance->GetObj()->SetSurface(window2);
622 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
623 OH_VideoProcessing::Destroy(instance);
624 OH_VideoProcessing::Destroy(instance2);
625 OH_VideoProcessing_DeinitializeEnvironment();
626 }
627
628 // set surface with nullptr
629 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_23, TestSize.Level1)
630 {
631 OH_VideoProcessing_InitializeEnvironment();
632 OH_VideoProcessing* instance = nullptr;
633 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
634 OHNativeWindow* window = nullptr;
635 VideoProcessing_ErrorCode ret = OH_VideoProcessing_SetSurface(instance, window);
636 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
637 OH_VideoProcessing_Destroy(instance);
638 OH_VideoProcessing_DeinitializeEnvironment();
639 }
640
641 // set surface with nullptr impl
642 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_23_1, TestSize.Level1)
643 {
644 OH_VideoProcessing_InitializeEnvironment();
645 OH_VideoProcessing* instance = nullptr;
646 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
647 OHNativeWindow* window = nullptr;
648 VideoProcessing_ErrorCode ret = instance->GetObj()->SetSurface(window);
649 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
650 OH_VideoProcessing::Destroy(instance);
651 OH_VideoProcessing_DeinitializeEnvironment();
652 }
653
654 // get surface to nullptr
655 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_24, TestSize.Level1)
656 {
657 OH_VideoProcessing_InitializeEnvironment();
658 OH_VideoProcessing* instance = nullptr;
659 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
660 OHNativeWindow* window = nullptr;
661 VideoProcessing_ErrorCode ret = OH_VideoProcessing_GetSurface(instance, &window);
662 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
663 OH_VideoProcessing_Destroy(instance);
664 OH_VideoProcessing_DeinitializeEnvironment();
665 }
666
667 // get surface to nullptr impl
668 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_24_1, TestSize.Level1)
669 {
670 OH_VideoProcessing_InitializeEnvironment();
671 OH_VideoProcessing* instance = nullptr;
672 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
673 OHNativeWindow* window = nullptr;
674 VideoProcessing_ErrorCode ret = instance->GetObj()->GetSurface(&window);
675 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
676 OH_VideoProcessing::Destroy(instance);
677 OH_VideoProcessing_DeinitializeEnvironment();
678 }
679
680 // create callback function
681 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_25, TestSize.Level1)
682 {
683 OH_VideoProcessing_InitializeEnvironment();
684 OH_VideoProcessing* instance = nullptr;
685 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
686 VideoProcessing_Callback* callback = nullptr;
687 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
688 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
689 OH_VideoProcessing_Destroy(instance);
690 OH_VideoProcessing_DeinitializeEnvironment();
691 }
692
693 // create callback function impl
694 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_25_1, TestSize.Level1)
695 {
696 OH_VideoProcessing_InitializeEnvironment();
697 OH_VideoProcessing* instance = nullptr;
698 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
699 VideoProcessing_Callback* callback = nullptr;
700 VideoProcessing_ErrorCode ret = VideoProcessing_Callback::Create(&callback);
701 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
702 OH_VideoProcessing::Destroy(instance);
703 OH_VideoProcessing_DeinitializeEnvironment();
704 }
705
706 // create and destroy callback function
707 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_26, TestSize.Level1)
708 {
709 OH_VideoProcessing_InitializeEnvironment();
710 OH_VideoProcessing* instance = nullptr;
711 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
712 VideoProcessing_Callback* callback = nullptr;
713 OH_VideoProcessingCallback_Create(&callback);
714 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Destroy(callback);
715 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
716 OH_VideoProcessing_Destroy(instance);
717 OH_VideoProcessing_DeinitializeEnvironment();
718 }
719
720 // create and destroy callback function impl
721 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_26_1, TestSize.Level1)
722 {
723 OH_VideoProcessing_InitializeEnvironment();
724 OH_VideoProcessing* instance = nullptr;
725 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
726 VideoProcessing_Callback* callback = nullptr;
727 VideoProcessing_Callback::Create(&callback);
728 VideoProcessing_ErrorCode ret = VideoProcessing_Callback::Destroy(callback);
729 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
730 OH_VideoProcessing::Destroy(instance);
731 OH_VideoProcessing_DeinitializeEnvironment();
732 }
733
734 // destroy callback without create
735 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_27, TestSize.Level1)
736 {
737 VideoProcessing_Callback* callback = nullptr;
738 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Destroy(callback);
739 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
740 }
741
742 // destroy callback without create impl
743 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_27_1, TestSize.Level1)
744 {
745 VideoProcessing_Callback* callback = nullptr;
746 VideoProcessing_ErrorCode ret = VideoProcessing_Callback::Destroy(callback);
747 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
748 }
749
750 // create callback function then register
751 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_28, TestSize.Level1)
752 {
753 OH_VideoProcessing_InitializeEnvironment();
754 OH_VideoProcessing* instance = nullptr;
755 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
756 VideoProcessing_Callback* callback = nullptr;
757 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
758 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
759 ret = OH_VideoProcessingCallback_BindOnError(callback, OnError);
760 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
761 ret = OH_VideoProcessingCallback_BindOnState(callback, OnState);
762 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
763 ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
764 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
765 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
766 ret = OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
767 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
768 OH_VideoProcessing_Destroy(instance);
769 OH_VideoProcessing_DeinitializeEnvironment();
770 }
771
772 // create callback function then register impl
773 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_28_1, TestSize.Level1)
774 {
775 OH_VideoProcessing_InitializeEnvironment();
776 OH_VideoProcessing* instance = nullptr;
777 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
778 VideoProcessing_Callback* callback = nullptr;
779 VideoProcessing_ErrorCode ret = VideoProcessing_Callback::Create(&callback);
780 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
781 ret = callback->GetObj()->BindOnError(OnError);
782 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
783 ret = callback->GetObj()->BindOnState(OnState);
784 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
785 ret = callback->GetObj()->BindOnNewOutputBuffer(OnNewOutputBuffer);
786 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
787 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
788 ret = instance->GetObj()->RegisterCallback(callback, &userData);
789 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
790 VideoProcessing_Callback::Destroy(callback);
791 OH_VideoProcessing::Destroy(instance);
792 OH_VideoProcessing_DeinitializeEnvironment();
793 }
794
795 // create callback but register null function
796 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_29, TestSize.Level1)
797 {
798 OH_VideoProcessing_InitializeEnvironment();
799 OH_VideoProcessing* instance = nullptr;
800 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
801 VideoProcessing_Callback* callback = nullptr;
802 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
803 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
804 ret = OH_VideoProcessingCallback_BindOnError(callback, nullptr);
805 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
806 ret = OH_VideoProcessingCallback_BindOnState(callback, nullptr);
807 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
808 ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, nullptr);
809 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
810 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
811 ret = OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
812 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
813 OH_VideoProcessing_Destroy(instance);
814 OH_VideoProcessingCallback_Destroy(callback);
815 OH_VideoProcessing_DeinitializeEnvironment();
816 }
817
818 // create callback but register null function impl
819 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_29_1, TestSize.Level1)
820 {
821 OH_VideoProcessing_InitializeEnvironment();
822 OH_VideoProcessing* instance = nullptr;
823 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
824 VideoProcessing_Callback* callback = nullptr;
825 VideoProcessing_ErrorCode ret = VideoProcessing_Callback::Create(&callback);
826 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
827 ret = callback->GetObj()->BindOnError(nullptr);
828 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
829 ret = callback->GetObj()->BindOnState(nullptr);
830 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
831 ret = callback->GetObj()->BindOnNewOutputBuffer(nullptr);
832 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
833 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
834 ret = instance->GetObj()->RegisterCallback(callback, &userData);
835 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
836 VideoProcessing_Callback::Destroy(callback);
837 OH_VideoProcessing::Destroy(instance);
838 OH_VideoProcessing_DeinitializeEnvironment();
839 }
840
841 // createa and destroy callback function with register
842 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_30, TestSize.Level1)
843 {
844 OH_VideoProcessing_InitializeEnvironment();
845 OH_VideoProcessing* instance = nullptr;
846 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
847 VideoProcessing_Callback* callback = nullptr;
848 OH_VideoProcessingCallback_Create(&callback);
849 OH_VideoProcessingCallback_BindOnError(callback, OnError);
850 OH_VideoProcessingCallback_BindOnState(callback, OnState);
851 OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
852 auto userData = nullptr;
853 VideoProcessing_ErrorCode ret = OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
854 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
855 ret = OH_VideoProcessingCallback_Destroy(callback);
856 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
857 OH_VideoProcessing_Destroy(instance);
858 OH_VideoProcessing_DeinitializeEnvironment();
859 }
860
861 // createa and destroy callback function with register impl
862 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_30_1, TestSize.Level1)
863 {
864 OH_VideoProcessing_InitializeEnvironment();
865 OH_VideoProcessing* instance = nullptr;
866 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
867 VideoProcessing_Callback* callback = nullptr;
868 VideoProcessing_Callback::Create(&callback);
869 callback->GetObj()->BindOnError(OnError);
870 callback->GetObj()->BindOnState(OnState);
871 callback->GetObj()->BindOnNewOutputBuffer(OnNewOutputBuffer);
872 auto userData = nullptr;
873 VideoProcessing_ErrorCode ret = instance->GetObj()->RegisterCallback(callback, &userData);
874 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
875 ret = VideoProcessing_Callback::Destroy(callback);
876 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
877 OH_VideoProcessing::Destroy(instance);
878 OH_VideoProcessing_DeinitializeEnvironment();
879 }
880
881 // create callback and register but instance is nullptr
882 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_31, TestSize.Level1)
883 {
884 OH_VideoProcessing_InitializeEnvironment();
885 OH_VideoProcessing* instance = nullptr;
886 VideoProcessing_Callback* callback = nullptr;
887 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
888 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
889 ret = OH_VideoProcessingCallback_BindOnError(callback, OnError);
890 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
891 ret = OH_VideoProcessingCallback_BindOnState(callback, OnState);
892 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
893 ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
894 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
895 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
896 OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
897 OH_VideoProcessing_DeinitializeEnvironment();
898 }
899
900 // create callback and register but callback is nullptr
901 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_32, TestSize.Level1)
902 {
903 OH_VideoProcessing_InitializeEnvironment();
904 OH_VideoProcessing* instance = nullptr;
905 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
906 VideoProcessing_Callback* callback = nullptr;
907 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_BindOnError(callback, OnError);
908 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
909 ret = OH_VideoProcessingCallback_BindOnState(callback, OnState);
910 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
911 ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
912 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
913 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
914 ret = OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
915 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
916 OH_VideoProcessing_Destroy(instance);
917 OH_VideoProcessing_DeinitializeEnvironment();
918 }
919
920 // start processing with flush surface then stop
921 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_33, TestSize.Level1)
922 {
923 OHNativeWindowBuffer *ohNativeWindowBuffer;
924 OH_VideoProcessing_InitializeEnvironment();
925 OH_VideoProcessing* instance = nullptr;
926 OH_VideoProcessing* instance2 = nullptr;
927 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
928 OH_VideoProcessing_Create(&instance2, CREATE_TYPE);
929 VideoProcessing_Callback* callback = nullptr;
930 OH_VideoProcessingCallback_Create(&callback);
931 OH_VideoProcessingCallback_BindOnError(callback, OnError);
932 OH_VideoProcessingCallback_BindOnState(callback, OnState);
933 OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
934 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
935 OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
936 OH_AVFormat* parameterSetted = OH_AVFormat_Create();
937 OH_AVFormat_SetIntValue(parameterSetted, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
938 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
939 OH_VideoProcessing_SetParameter(instance, parameterSetted);
940 OHNativeWindow* window = nullptr;
941 OHNativeWindow* window2 = nullptr;
942 OH_VideoProcessing_GetSurface(instance, &window);
943 OH_VideoProcessing_GetSurface(instance2, &window2);
944 OH_VideoProcessing_SetSurface(instance, window2);
945 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Start(instance);
946 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
947 OH_NativeWindow_NativeWindowHandleOpt(window, SET_FORMAT, NV12_FMT_INDEX);
948 OH_NativeWindow_NativeWindowHandleOpt(window, SET_BUFFER_GEOMETRY, DEFAULT_WIDTH, DEFAULT_HEIGHT);
949 int fenceFd = -1;
950 OH_NativeWindow_NativeWindowRequestBuffer(window, &ohNativeWindowBuffer, &fenceFd);
951 FlushSurf(ohNativeWindowBuffer, window);
952 ret = OH_VideoProcessing_Stop(instance);
953 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
954 OH_VideoProcessingCallback_Destroy(callback);
955 OH_VideoProcessing_Destroy(instance);
956 OH_VideoProcessing_DeinitializeEnvironment();
957 }
958
959 // start processing with flush surface then stop impl
960 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_33_1, TestSize.Level1)
961 {
962 OHNativeWindowBuffer *ohNativeWindowBuffer;
963 OH_VideoProcessing_InitializeEnvironment();
964 OH_VideoProcessing* instance = nullptr;
965 OH_VideoProcessing* instance2 = nullptr;
966 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
967 OH_VideoProcessing::Create(&instance2, CREATE_TYPE);
968 VideoProcessing_Callback* callback = nullptr;
969 VideoProcessing_Callback::Create(&callback);
970 callback->GetObj()->BindOnError(OnError);
971 callback->GetObj()->BindOnState(OnState);
972 callback->GetObj()->BindOnNewOutputBuffer(OnNewOutputBuffer);
973 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
974 instance->GetObj()->RegisterCallback(callback, &userData);
975 OH_AVFormat* parameterSetted = OH_AVFormat_Create();
976 OH_AVFormat_SetIntValue(parameterSetted, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
977 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
978 instance->GetObj()->SetParameter(parameterSetted);
979 OHNativeWindow* window = nullptr;
980 OHNativeWindow* window2 = nullptr;
981 instance->GetObj()->GetSurface(&window);
982 instance->GetObj()->GetSurface(&window2);
983 instance->GetObj()->SetSurface(window2);
984 VideoProcessing_ErrorCode ret = instance->GetObj()->Start();
985 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
986 OH_NativeWindow_NativeWindowHandleOpt(window, SET_FORMAT, NV12_FMT_INDEX);
987 OH_NativeWindow_NativeWindowHandleOpt(window, SET_BUFFER_GEOMETRY, DEFAULT_WIDTH, DEFAULT_HEIGHT);
988 int fenceFd = -1;
989 OH_NativeWindow_NativeWindowRequestBuffer(window, &ohNativeWindowBuffer, &fenceFd);
990 FlushSurf(ohNativeWindowBuffer, window);
991 ret = instance->GetObj()->Stop();
992 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
993 VideoProcessing_Callback::Destroy(callback);
994 OH_VideoProcessing::Destroy(instance);
995 OH_VideoProcessing::Destroy(instance2);
996 OH_VideoProcessing_DeinitializeEnvironment();
997 }
998
999 // bind on null callback
1000 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_34, TestSize.Level1)
1001 {
1002 OHNativeWindowBuffer *ohNativeWindowBuffer;
1003 OH_VideoProcessing_InitializeEnvironment();
1004 OH_VideoProcessing* instance = nullptr;
1005 OH_VideoProcessing* instance2 = nullptr;
1006 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
1007 OH_VideoProcessing_Create(&instance2, CREATE_TYPE);
1008 VideoProcessing_Callback* callback = nullptr;
1009 OH_VideoProcessingCallback_Create(&callback);
1010 OH_VideoProcessingCallback_BindOnError(callback, nullptr);
1011 OH_VideoProcessingCallback_BindOnState(callback, nullptr);
1012 OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, nullptr);
1013 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
1014 OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
1015 OH_AVFormat* parameterSetted = OH_AVFormat_Create();
1016 OH_AVFormat_SetIntValue(parameterSetted, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
1017 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
1018 OH_VideoProcessing_SetParameter(instance, parameterSetted);
1019 OHNativeWindow* window = nullptr;
1020 OHNativeWindow* window2 = nullptr;
1021 OH_VideoProcessing_GetSurface(instance, &window);
1022 OH_VideoProcessing_GetSurface(instance2, &window2);
1023 OH_VideoProcessing_SetSurface(instance, window2);
1024 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Start(instance);
1025 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
1026 OH_NativeWindow_NativeWindowHandleOpt(window, SET_FORMAT, NV12_FMT_INDEX);
1027 OH_NativeWindow_NativeWindowHandleOpt(window, SET_BUFFER_GEOMETRY, DEFAULT_WIDTH, DEFAULT_HEIGHT);
1028 int fenceFd = -1;
1029 OH_NativeWindow_NativeWindowRequestBuffer(window, &ohNativeWindowBuffer, &fenceFd);
1030 FlushSurf(ohNativeWindowBuffer, window);
1031 ret = OH_VideoProcessing_Stop(instance);
1032 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
1033 OH_VideoProcessingCallback_Destroy(callback);
1034 OH_VideoProcessing_Destroy(instance);
1035 OH_VideoProcessing_Destroy(instance2);
1036 OH_VideoProcessing_DeinitializeEnvironment();
1037 }
1038
1039 // bind on null callback impl
1040 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_34_1, TestSize.Level1)
1041 {
1042 OHNativeWindowBuffer *ohNativeWindowBuffer;
1043 OH_VideoProcessing_InitializeEnvironment();
1044 OH_VideoProcessing* instance = nullptr;
1045 OH_VideoProcessing* instance2 = nullptr;
1046 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
1047 OH_VideoProcessing::Create(&instance2, CREATE_TYPE);
1048 VideoProcessing_Callback* callback = nullptr;
1049 VideoProcessing_Callback::Create(&callback);
1050 callback->GetObj()->BindOnError(nullptr);
1051 callback->GetObj()->BindOnState(nullptr);
1052 callback->GetObj()->BindOnNewOutputBuffer(nullptr);
1053 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
1054 instance->GetObj()->RegisterCallback(callback, &userData);
1055 OH_AVFormat* parameterSetted = OH_AVFormat_Create();
1056 OH_AVFormat_SetIntValue(parameterSetted, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
1057 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
1058 instance->GetObj()->SetParameter(parameterSetted);
1059 OHNativeWindow* window = nullptr;
1060 OHNativeWindow* window2 = nullptr;
1061 instance->GetObj()->GetSurface(&window);
1062 instance->GetObj()->GetSurface(&window2);
1063 instance->GetObj()->SetSurface(window2);
1064 VideoProcessing_ErrorCode ret = instance->GetObj()->Start();
1065 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
1066 OH_NativeWindow_NativeWindowHandleOpt(window, SET_FORMAT, NV12_FMT_INDEX);
1067 OH_NativeWindow_NativeWindowHandleOpt(window, SET_BUFFER_GEOMETRY, DEFAULT_WIDTH, DEFAULT_HEIGHT);
1068 int fenceFd = -1;
1069 OH_NativeWindow_NativeWindowRequestBuffer(window, &ohNativeWindowBuffer, &fenceFd);
1070 FlushSurf(ohNativeWindowBuffer, window);
1071 ret = instance->GetObj()->Stop();
1072 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
1073 VideoProcessing_Callback::Destroy(callback);
1074 OH_VideoProcessing::Destroy(instance);
1075 OH_VideoProcessing::Destroy(instance2);
1076 OH_VideoProcessing_DeinitializeEnvironment();
1077 }
1078
1079 // register null callback
1080 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_34_2, TestSize.Level1)
1081 {
1082 OHNativeWindowBuffer *ohNativeWindowBuffer;
1083 OH_VideoProcessing_InitializeEnvironment();
1084 OH_VideoProcessing* instance = nullptr;
1085 OH_VideoProcessing* instance2 = nullptr;
1086 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
1087 OH_VideoProcessing_Create(&instance2, CREATE_TYPE);
1088 VideoProcessing_Callback* callback = nullptr;
1089 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
1090 OH_VideoProcessing_RegisterCallback(instance, nullptr, &userData);
1091 OH_AVFormat* parameterSetted = OH_AVFormat_Create();
1092 OH_AVFormat_SetIntValue(parameterSetted, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
1093 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
1094 OH_VideoProcessing_SetParameter(instance, parameterSetted);
1095 OHNativeWindow* window = nullptr;
1096 OHNativeWindow* window2 = nullptr;
1097 OH_VideoProcessing_GetSurface(instance, &window);
1098 OH_VideoProcessing_GetSurface(instance2, &window2);
1099 OH_VideoProcessing_SetSurface(instance, window2);
1100 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Start(instance);
1101 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
1102 OH_NativeWindow_NativeWindowHandleOpt(window, SET_FORMAT, NV12_FMT_INDEX);
1103 OH_NativeWindow_NativeWindowHandleOpt(window, SET_BUFFER_GEOMETRY, DEFAULT_WIDTH, DEFAULT_HEIGHT);
1104 int fenceFd = -1;
1105 OH_NativeWindow_NativeWindowRequestBuffer(window, &ohNativeWindowBuffer, &fenceFd);
1106 FlushSurf(ohNativeWindowBuffer, window);
1107 ret = OH_VideoProcessing_Stop(instance);
1108 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
1109 OH_VideoProcessingCallback_Destroy(callback);
1110 OH_VideoProcessing_Destroy(instance);
1111 OH_VideoProcessing_Destroy(instance2);
1112 OH_VideoProcessing_DeinitializeEnvironment();
1113 }
1114
1115 // register null callback impl
1116 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_34_3, TestSize.Level1)
1117 {
1118 OHNativeWindowBuffer *ohNativeWindowBuffer;
1119 OH_VideoProcessing_InitializeEnvironment();
1120 OH_VideoProcessing* instance = nullptr;
1121 OH_VideoProcessing* instance2 = nullptr;
1122 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
1123 OH_VideoProcessing::Create(&instance2, CREATE_TYPE);
1124 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
1125 instance->GetObj()->RegisterCallback(nullptr, &userData);
1126 OH_AVFormat* parameterSetted = OH_AVFormat_Create();
1127 OH_AVFormat_SetIntValue(parameterSetted, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
1128 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
1129 instance->GetObj()->SetParameter(parameterSetted);
1130 OHNativeWindow* window = nullptr;
1131 OHNativeWindow* window2 = nullptr;
1132 instance->GetObj()->GetSurface(&window);
1133 instance->GetObj()->GetSurface(&window2);
1134 instance->GetObj()->SetSurface(window2);
1135 VideoProcessing_ErrorCode ret = instance->GetObj()->Start();
1136 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
1137 OH_NativeWindow_NativeWindowHandleOpt(window, SET_FORMAT, NV12_FMT_INDEX);
1138 OH_NativeWindow_NativeWindowHandleOpt(window, SET_BUFFER_GEOMETRY, DEFAULT_WIDTH, DEFAULT_HEIGHT);
1139 int fenceFd = -1;
1140 OH_NativeWindow_NativeWindowRequestBuffer(window, &ohNativeWindowBuffer, &fenceFd);
1141 FlushSurf(ohNativeWindowBuffer, window);
1142 ret = instance->GetObj()->Stop();
1143 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
1144 OH_VideoProcessing::Destroy(instance);
1145 OH_VideoProcessing::Destroy(instance2);
1146 OH_VideoProcessing_DeinitializeEnvironment();
1147 }
1148
1149 // call output buffer
1150 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_35, TestSize.Level1)
1151 {
1152 OH_VideoProcessing_InitializeEnvironment();
1153 OH_VideoProcessing* instance = nullptr;
1154 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
1155 OH_VideoProcessing_RenderOutputBuffer(instance, 0);
1156 OH_VideoProcessing_Destroy(instance);
1157 VideoProcessing_ErrorCode ret = OH_VideoProcessing_DeinitializeEnvironment();
1158 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1159 }
1160
1161 // call output buffer impl
1162 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_35_1, TestSize.Level1)
1163 {
1164 OH_VideoProcessing_InitializeEnvironment();
1165 OH_VideoProcessing* instance = nullptr;
1166 OH_VideoProcessing::Create(&instance, CREATE_TYPE);
1167 instance->GetObj()->RenderOutputBuffer(0);
1168 OH_VideoProcessing::Destroy(instance);
1169 VideoProcessing_ErrorCode ret = OH_VideoProcessing_DeinitializeEnvironment();
1170 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1171 }
1172
1173 // callback native
1174 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_36, TestSize.Level1)
1175 {
1176 OH_VideoProcessing* instance = nullptr;
1177 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&instance, CREATE_TYPE);
1178 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1179 auto callback = std::make_shared<VideoProcessingEngine::VideoProcessingCallbackNative>();
1180 callback->OnError(instance, VIDEO_PROCESSING_SUCCESS, nullptr);
1181 callback->OnState(instance, VIDEO_PROCESSING_STATE_RUNNING, nullptr);
1182 callback->OnNewOutputBuffer(instance, 0, nullptr);
1183 }
1184
CreateSurfaceBuffer(uint32_t pixelFormat,int32_t width,int32_t height)1185 sptr<SurfaceBuffer> CreateSurfaceBuffer(uint32_t pixelFormat, int32_t width, int32_t height)
1186 {
1187 auto buffer = SurfaceBuffer::Create();
1188 if (buffer == nullptr) {
1189 return nullptr;
1190 }
1191 if (width <= 0 || height <= 0) {
1192 return nullptr;
1193 }
1194 BufferRequestConfig inputCfg;
1195 inputCfg.width = width;
1196 inputCfg.height = height;
1197 inputCfg.strideAlignment = width;
1198 inputCfg.usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA;
1199 inputCfg.format = pixelFormat;
1200 inputCfg.timeout = 0;
1201 GSError err = buffer->Alloc(inputCfg);
1202 if (err != GSERROR_OK) {
1203 return nullptr;
1204 }
1205 return buffer;
1206 }
1207
1208 // bind callback after start
1209 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_37, TestSize.Level1)
1210 {
1211 OH_VideoProcessing_InitializeEnvironment();
1212 OH_VideoProcessing* instance = nullptr;
1213 OH_VideoProcessing_Create(&instance, CREATE_TYPE);
1214 OH_VideoProcessing_Start(instance);
1215 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_BindOnError(nullptr, OnErrorEmptyCallback);
1216 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
1217 OH_VideoProcessing_Destroy(instance);
1218 OH_VideoProcessing_DeinitializeEnvironment();
1219 }
1220
1221 // sample multi thread start
1222 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_38, TestSize.Level1)
1223 {
1224 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1225 sample->SetQualityLevel(VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
1226 VideoProcessParam Param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_420_P, 480, 360,
1227 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_P, 1280, 720};
1228 int32_t ret = sample->InitVideoSample(Param);
1229 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1230 sample->StartProcess();
1231 EXPECT_EQ(sample->WaitAndStopSample(), VIDEO_PROCESSING_SUCCESS);
1232 }
1233
1234 // sample multi thread start Impl
1235 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_39, TestSize.Level1)
1236 {
1237 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1238 sample->SetImplLoader(true);
1239 sample->SetQualityLevel(VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
1240 VideoProcessParam Param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_420_P, 480, 360,
1241 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_P, 1280, 720};
1242 int32_t ret = sample->InitVideoSampleImpl(Param);
1243 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1244 sample->StartProcessImpl();
1245 EXPECT_EQ(sample->WaitAndStopSampleImpl(), VIDEO_PROCESSING_SUCCESS);
1246 }
1247
1248 // set surface on running Impl
1249 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_40, TestSize.Level1)
1250 {
1251 std::unique_ptr<VideoSample> sample = std::make_unique<VideoSample>();
1252 sample->SetImplLoader(true);
1253 sample->SetQualityLevel(VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
1254 VideoProcessParam Param = {NATIVEBUFFER_PIXEL_FMT_YCRCB_420_P, 480, 360,
1255 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_P, 1280, 720};
1256 int32_t ret = sample->InitVideoSampleImpl(Param);
1257 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1258 sample->StartProcessImpl();
1259 EXPECT_EQ(sample->SetSurfaceOnRunningImpl(), VIDEO_PROCESSING_SUCCESS);
1260 EXPECT_EQ(sample->WaitAndStopSampleImpl(), VIDEO_PROCESSING_SUCCESS);
1261 }
1262
1263 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_41, TestSize.Level1)
1264 {
1265 DetailEnhancer enhancer;
1266 enhancer.Initialize();
1267 enhancer.Initialize();
1268 sptr<SurfaceBuffer> input = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_8888, 1024, 1024);
1269 sptr<SurfaceBuffer> output = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_8888, 1024, 1024);
1270 AlgoErrorCode ret = enhancer.Process(input, output);
1271 EXPECT_NE(ret, ALGO_SUCCESS);
1272 enhancer.Deinitialize();
1273 enhancer.Deinitialize();
1274 }
1275
1276 #ifdef SKIA_ENABLE
1277 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_42, TestSize.Level1)
1278 {
1279 Media::VideoProcessingEngine::Skia skiaImpl;
1280 sptr<SurfaceBuffer> input = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_YUV_422_I, 1024, 1024);
1281 sptr<SurfaceBuffer> output = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_YUV_422_I, 1024, 1024);
1282 AlgoErrorCode ret = skiaImpl.Process(input, output);
1283 input = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_8888, 1024, 1024);
1284 output = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_YUV_422_I, 1024, 1024);
1285 ret = skiaImpl.Process(input, output);
1286 EXPECT_NE(ret, ALGO_SUCCESS);
1287 input = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_8888, 1024, 1024);
1288 output = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_8888, 1024, 1024);
1289 ret = skiaImpl.Process(input, output);
1290 EXPECT_EQ(ret, ALGO_SUCCESS);
1291 input = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_BGRA_8888, 1024, 1024);
1292 output = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_BGRA_8888, 1024, 1024);
1293 ret = skiaImpl.Process(input, output);
1294 EXPECT_EQ(ret, ALGO_SUCCESS);
1295 input = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_YCBCR_420_SP, 1024, 1024);
1296 output = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_YCBCR_420_SP, 1024, 1024);
1297 ret = skiaImpl.Process(input, output);
1298 EXPECT_EQ(ret, ALGO_SUCCESS);
1299 input = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_YCRCB_420_SP, 1024, 1024);
1300 output = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_YCRCB_420_SP, 1024, 1024);
1301 ret = skiaImpl.Process(input, output);
1302 EXPECT_EQ(ret, ALGO_SUCCESS);
1303 input = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_YCBCR_420_P, 1024, 1024);
1304 output = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_YCBCR_420_P, 1024, 1024);
1305 ret = skiaImpl.Process(input, output);
1306 EXPECT_EQ(ret, ALGO_SUCCESS);
1307 input = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_YCRCB_420_P, 1024, 1024);
1308 output = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_YCRCB_420_P, 1024, 1024);
1309 ret = skiaImpl.Process(input, output);
1310 EXPECT_EQ(ret, ALGO_SUCCESS);
1311 }
1312 #endif
1313
1314 // native impl inner test
1315 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_43, TestSize.Level1)
1316 {
1317 OH_VideoProcessing* instance = nullptr;
1318 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&instance, CREATE_TYPE);
1319 VideoProcessingNative videoNative(instance);
1320 ret = videoNative.InitializeInner();
1321 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1322 OHOS::Media::Format parameter;
1323 videoNative.SetSurface(nullptr);
1324 videoNative.GetSurface(nullptr);
1325 OH_VideoProcessing* instanceTmp = nullptr;
1326 OH_VideoProcessing::Create(&instanceTmp, CREATE_TYPE);
1327 OHNativeWindow* window = nullptr;
1328 struct Region region;
1329 struct Region::Rect *rect = new Region::Rect();
1330 rect->x = 0;
1331 rect->y = 0;
1332 rect->w = DEFAULT_WIDTH;
1333 rect->h = DEFAULT_HEIGHT;
1334 region.rects = rect;
1335 NativeWindowHandleOpt(window, SET_UI_TIMESTAMP, GetSystemTime());
1336 instanceTmp->GetObj()->GetSurface(&window);
1337 videoNative.SetSurface(window);
1338 videoNative.GetSurface(nullptr);
1339 ret = videoNative.SetParameter(parameter);
1340 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1341 ret = videoNative.GetParameter(parameter);
1342 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1343 sptr<SurfaceBuffer> input = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_8888, 1024, 1024);
1344 sptr<SurfaceBuffer> output = CreateSurfaceBuffer(OHOS::GRAPHIC_PIXEL_FMT_RGBA_8888, 1024, 1024);
1345 videoNative.ProcessBuffers();
1346 ret = videoNative.Process(input, output);
1347 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1348 videoNative.UpdateRequestCfg(input, bufferConfig1);
1349 videoNative.UpdateRequestCfg(input, bufferConfig2);
1350 videoNative.UpdateRequestCfg(input, bufferConfig3);
1351 videoNative.UpdateRequestCfg(input, bufferConfig4);
1352 videoNative.Deinitialize();
1353 videoNative.SetProducerSurface(*window, bufferConfig4);
1354 videoNative.OnError(VIDEO_PROCESSING_SUCCESS);
1355 videoNative.OnNewOutputBuffer(1);
1356 videoNative.OnProducerBufferReleased();
1357 videoNative.RenderOutputBufferInner(1);
1358 videoNative.ProcessBuffers();
1359 std::unique_lock<std::mutex> lock;
__anon1cea636d0102null1360 videoNative.WaitCV([this] {return 1;}, lock);
1361 }
1362
1363 HWTEST_F(DetailEnhancerVideoNdkUnitTest, vpeVideoNdk_44, TestSize.Level1)
1364 {
1365 VideoProcessingNdkLoader::Get().UnloadLibrary();
1366 VideoProcessingNdkLoader::Get().LoadLibrary();
1367 VideoProcessingNdkLoader::Get().UnloadLibrary();
1368 VideoProcessingNdkLoader::Get().LoadLibrary();
1369 bool ret = VideoProcessingNdkLoader::Get().LoadLibrary();
1370 if (!access("/system/lib64/", 0)) {
1371 EXPECT_EQ(ret, true);
1372 } else {
1373 EXPECT_EQ(ret, false);
1374 }
1375 VideoProcessingNdkLoader::Get().UnloadLibrary();
1376 VideoProcessingNdkLoader::Get().UnloadLibrary();
1377 VideoProcessingNdkLoader::Get().UnloadLibrary();
1378 }
1379
1380 }
1381 } // namespace Media
1382 } // namespace OHOS
1383