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