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