1 /*
2 * Copyright (c) 2025 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
16 #include <condition_variable>
17 #include <mutex>
18
19 #include <unistd.h>
20
21 #include <gtest/gtest.h>
22
23 #include "native_avformat.h"
24
25 #include "video_processing.h"
26 #include "video_processing_types.h"
27 #include "video_processing_callback_impl.h"
28 #include "video_processing_callback_native.h"
29 #include "video_environment_native.h"
30 #include "video_processing_impl.h"
31
32 #include "detail_enhancer_video_impl.h"
33 #include "detail_enhancer_video.h"
34 #include "surface/window.h"
35 #include "external_window.h"
36
37 namespace {
38 constexpr int64_t NANOS_IN_SECOND = 1000000000L;
39 constexpr int64_t NANOS_IN_MICRO = 1000L;
40 constexpr uint32_t DEFAULT_WIDTH = 1920;
41 constexpr uint32_t DEFAULT_HEIGHT = 1080;
42
43 std::condition_variable g_cvStop{};
44 std::mutex g_lock{};
45 bool g_isStoped = true;
46
WaitForStop()47 void WaitForStop()
48 {
49 std::cout << "wait for stop flag" << std::endl;
50 std::unique_lock<std::mutex> lock(g_lock);
51 g_cvStop.wait(lock, [] { return g_isStoped; });
52 std::cout << "stop flag is " << g_isStoped << std::endl;
53 }
54 }
55
56 using namespace std;
57 using namespace testing::ext;
58
59 namespace OHOS {
60 namespace Media {
61 namespace VideoProcessingEngine {
62
OnError(OH_VideoProcessing * handle,VideoProcessing_ErrorCode errorCode,void * userData)63 void OnError(OH_VideoProcessing *handle, VideoProcessing_ErrorCode errorCode, void* userData)
64 {
65 // do something
66 }
OnState(OH_VideoProcessing * instance,VideoProcessing_State state,void * userData)67 void OnState(OH_VideoProcessing* instance, VideoProcessing_State state, void* userData)
68 {
69 if (state == VIDEO_PROCESSING_STATE_STOPPED) {
70 std::cout << "state is VIDEO_PROCESSING_STATE_STOPPED" << std::endl;
71 {
72 std::lock_guard<std::mutex> lock(g_lock);
73 g_isStoped = true;
74 }
75 g_cvStop.notify_one();
76 } else {
77 std::cout << "state is VIDEO_PROCESSING_STATE_RUNNING" << std::endl;
78 std::lock_guard<std::mutex> lock(g_lock);
79 g_isStoped = false;
80 std::cout << "start and stop flag is false" << std::endl;
81 }
82 if (userData != nullptr) {
83 VideoProcessing_State* userState = static_cast<VideoProcessing_State*>(userData);
84 *userState = state;
85 }
86 }
87
OnNewOutputBuffer(OH_VideoProcessing * instance,uint32_t index,void * userData)88 void OnNewOutputBuffer(OH_VideoProcessing* instance, uint32_t index, void* userData)
89 {
90 (void)userData;
91 (void)OH_VideoProcessing_RenderOutputBuffer(instance, index);
92 }
93
94
95 class DetailEnhancerVideoNdkUnitTest : public testing::Test {
96 public:
97 static void SetUpTestCase(void);
98 static void TearDownTestCase(void);
99 void SetUp();
100 void TearDown();
101 sptr<Surface> surface;
102 uint32_t FlushSurf(OHNativeWindowBuffer *ohNativeWindowBuffer, OHNativeWindow *window);
103 };
104
SetUpTestCase(void)105 void DetailEnhancerVideoNdkUnitTest::SetUpTestCase(void)
106 {
107 cout << "[SetUpTestCase]: " << endl;
108 }
109
TearDownTestCase(void)110 void DetailEnhancerVideoNdkUnitTest::TearDownTestCase(void)
111 {
112 cout << "[TearDownTestCase]: " << endl;
113 }
114
SetUp(void)115 void DetailEnhancerVideoNdkUnitTest::SetUp(void)
116 {
117 cout << "[SetUp]: SetUp!!!" << endl;
118 }
119
TearDown(void)120 void DetailEnhancerVideoNdkUnitTest::TearDown(void)
121 {
122 cout << "[TearDown]: over!!!" << endl;
123 }
124
GetSystemTime()125 int64_t GetSystemTime()
126 {
127 struct timespec now;
128 (void)clock_gettime(CLOCK_BOOTTIME, &now);
129 int64_t nanoTime = reinterpret_cast<int64_t>(now.tv_sec) * NANOS_IN_SECOND + now.tv_nsec;
130
131 return nanoTime / NANOS_IN_MICRO;
132 }
133
FlushSurf(OHNativeWindowBuffer * ohNativeWindowBuffer,OHNativeWindow * window)134 uint32_t DetailEnhancerVideoNdkUnitTest::FlushSurf(OHNativeWindowBuffer *ohNativeWindowBuffer, OHNativeWindow *window)
135 {
136 struct Region region;
137 struct Region::Rect *rect = new Region::Rect();
138 rect->x = 0;
139 rect->y = 0;
140 rect->w = DEFAULT_WIDTH;
141 rect->h = DEFAULT_HEIGHT;
142 region.rects = rect;
143 NativeWindowHandleOpt(window, SET_UI_TIMESTAMP, GetSystemTime());
144 int32_t err = OH_NativeWindow_NativeWindowFlushBuffer(window, ohNativeWindowBuffer, -1, region);
145 delete rect;
146 if (err != 0) {
147 cout << "FlushBuffer failed" << endl;
148 return 1;
149 }
150 return 0;
151 }
152
153 // context init nullptr
154 HWTEST_F(DetailEnhancerVideoNdkUnitTest, create_instance_01, TestSize.Level1)
155 {
156 int createType = 0x4;
157 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
158 OH_VideoProcessing* instance = nullptr;
159 ret = OH_VideoProcessing_Create(&instance, createType);
160 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
161 ret = OH_VideoProcessing_Destroy(instance);
162 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
163 ret = OH_VideoProcessing_DeinitializeEnvironment();
164 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
165 }
166
167 // context create without init
168 HWTEST_F(DetailEnhancerVideoNdkUnitTest, create_instance_02, TestSize.Level1)
169 {
170 int createType = 0x4;
171 OH_VideoProcessing* instance = nullptr;
172 auto ret = OH_VideoProcessing_Create(&instance, createType);
173 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
174 ret = OH_VideoProcessing_Destroy(instance);
175 }
176
177 // context init 2
178 HWTEST_F(DetailEnhancerVideoNdkUnitTest, create_instance_03, TestSize.Level1)
179 {
180 int createType = 0x2;
181 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
182 OH_VideoProcessing* instance = nullptr;
183 ret = OH_VideoProcessing_Create(&instance, createType);
184 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
185 ret = OH_VideoProcessing_Destroy(instance);
186 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
187 ret = OH_VideoProcessing_DeinitializeEnvironment();
188 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
189 }
190
191 // context init 1
192 HWTEST_F(DetailEnhancerVideoNdkUnitTest, create_instance_04, TestSize.Level1)
193 {
194 int createType = 0x1;
195 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
196 OH_VideoProcessing* instance = nullptr;
197 ret = OH_VideoProcessing_Create(&instance, createType);
198 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
199 ret = OH_VideoProcessing_Destroy(instance);
200 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
201 ret = OH_VideoProcessing_DeinitializeEnvironment();
202 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
203 }
204
205 // context init -1
206 HWTEST_F(DetailEnhancerVideoNdkUnitTest, create_instance_05, TestSize.Level1)
207 {
208 int createType = -1;
209 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
210 OH_VideoProcessing* instance = nullptr;
211 ret = OH_VideoProcessing_Create(&instance, createType);
212 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
213 ret = OH_VideoProcessing_Destroy(instance);
214 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
215 ret = OH_VideoProcessing_DeinitializeEnvironment();
216 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
217 }
218
219 // context init repeat
220 HWTEST_F(DetailEnhancerVideoNdkUnitTest, create_instance_06, TestSize.Level1)
221 {
222 int createType = 0x4;
223 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
224 ret = OH_VideoProcessing_InitializeEnvironment();
225 ret = OH_VideoProcessing_InitializeEnvironment();
226 OH_VideoProcessing* instance = nullptr;
227 ret = OH_VideoProcessing_Create(&instance, createType);
228 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
229 ret = OH_VideoProcessing_Destroy(instance);
230 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
231 instance = nullptr;
232 ret = OH_VideoProcessing_Create(&instance, createType);
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 ret = OH_VideoProcessing_DeinitializeEnvironment();
238 ret = OH_VideoProcessing_DeinitializeEnvironment();
239 ret = OH_VideoProcessing_InitializeEnvironment();
240 ret = OH_VideoProcessing_DeinitializeEnvironment();
241 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
242 }
243
244 // deinit
245 HWTEST_F(DetailEnhancerVideoNdkUnitTest, deinit_01, TestSize.Level1)
246 {
247 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
248 ret = OH_VideoProcessing_DeinitializeEnvironment();
249 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
250 }
251
252 // context init and destroy
253 HWTEST_F(DetailEnhancerVideoNdkUnitTest, destroy_instance_01, TestSize.Level1)
254 {
255 int createType = 0x4;
256 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
257 OH_VideoProcessing* instance = nullptr;
258 ret = OH_VideoProcessing_Create(&instance, createType);
259 ret = OH_VideoProcessing_Destroy(instance);
260 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
261 OH_VideoProcessing_DeinitializeEnvironment();
262 }
263
264 // context no create but destroy
265 HWTEST_F(DetailEnhancerVideoNdkUnitTest, destroy_instance_02, TestSize.Level1)
266 {
267 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
268 OH_VideoProcessing* instance = nullptr;
269 ret = OH_VideoProcessing_Destroy(instance);
270 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
271 OH_VideoProcessing_DeinitializeEnvironment();
272 }
273
274 // context no create but destroy without initialize
275 HWTEST_F(DetailEnhancerVideoNdkUnitTest, destroy_instance_03, TestSize.Level1)
276 {
277 OH_VideoProcessing* instance = nullptr;
278 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Destroy(instance);
279 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
280 }
281
282 // color space converter support check
283 HWTEST_F(DetailEnhancerVideoNdkUnitTest, check_support_01, TestSize.Level1)
284 {
285 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
286 const VideoProcessing_ColorSpaceInfo* sourceVideoInfo = nullptr;
287 const VideoProcessing_ColorSpaceInfo* destinationVideoInfo = nullptr;
288 auto res = OH_VideoProcessing_IsColorSpaceConversionSupported(sourceVideoInfo, destinationVideoInfo);
289 EXPECT_EQ(res, false);
290 ret = OH_VideoProcessing_DeinitializeEnvironment();
291 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
292 }
293
294 // Set param nullptr
295 HWTEST_F(DetailEnhancerVideoNdkUnitTest, set_parameter_01, TestSize.Level1)
296 {
297 int createType = 0x4;
298 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
299 OH_VideoProcessing* instance = nullptr;
300 ret = OH_VideoProcessing_Create(&instance, createType);
301 OH_AVFormat* parameter = nullptr;
302 ret = OH_VideoProcessing_SetParameter(instance, parameter);
303 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
304 OH_VideoProcessing_Destroy(instance);
305 OH_VideoProcessing_DeinitializeEnvironment();
306 }
307
308 // set normal
309 HWTEST_F(DetailEnhancerVideoNdkUnitTest, set_parameter_02, TestSize.Level1)
310 {
311 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
312 int createType = 0x4;
313 OH_VideoProcessing* instance = nullptr;
314 ret = OH_VideoProcessing_Create(&instance, createType);
315 OH_AVFormat* parameter = OH_AVFormat_Create();
316 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
317 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
318 ret = OH_VideoProcessing_SetParameter(instance, parameter);
319 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
320 OH_VideoProcessing_Destroy(instance);
321 OH_VideoProcessing_DeinitializeEnvironment();
322 }
323
324 // get parameter but param not null
325 HWTEST_F(DetailEnhancerVideoNdkUnitTest, get_parameter_01, TestSize.Level1)
326 {
327 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
328 int createType = 0x4;
329 OH_VideoProcessing* instance = nullptr;
330 ret = OH_VideoProcessing_Create(&instance, createType);
331 OH_AVFormat* parameter = OH_AVFormat_Create();
332 ret = OH_VideoProcessing_GetParameter(instance, parameter);
333 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
334 OH_VideoProcessing_Destroy(instance);
335 OH_VideoProcessing_DeinitializeEnvironment();
336 }
337
338 // get parameter normal
339 HWTEST_F(DetailEnhancerVideoNdkUnitTest, get_parameter_02, TestSize.Level1)
340 {
341 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
342 int createType = 0x4;
343 OH_VideoProcessing* instance = nullptr;
344 ret = OH_VideoProcessing_Create(&instance, createType);
345 OH_AVFormat* parameter = nullptr;
346 ret = OH_VideoProcessing_GetParameter(instance, parameter);
347 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
348 OH_VideoProcessing_Destroy(instance);
349 OH_VideoProcessing_DeinitializeEnvironment();
350 }
351
352 // get parameter normal after set
353 HWTEST_F(DetailEnhancerVideoNdkUnitTest, get_parameter_03, TestSize.Level1)
354 {
355 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
356 int createType = 0x4;
357 OH_VideoProcessing* instance = nullptr;
358 ret = OH_VideoProcessing_Create(&instance, createType);
359 OH_AVFormat* parameterSetted = OH_AVFormat_Create();
360 OH_AVFormat* parameterGetted = OH_AVFormat_Create();
361 OH_AVFormat_SetIntValue(parameterSetted, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
362 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
363 ret = OH_VideoProcessing_SetParameter(instance, parameterSetted);
364 ret = OH_VideoProcessing_GetParameter(instance, parameterGetted);
365 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
366 OH_VideoProcessing_Destroy(instance);
367 OH_VideoProcessing_DeinitializeEnvironment();
368 }
369
370 // set surface with nullptr
371 HWTEST_F(DetailEnhancerVideoNdkUnitTest, set_surface_01, TestSize.Level1)
372 {
373 OH_VideoProcessing_InitializeEnvironment();
374 int createType = 0x4;
375 OH_VideoProcessing* instance = nullptr;
376 OH_VideoProcessing* instance2 = nullptr;
377 OHNativeWindow* window;
378 OHNativeWindow* window2;
379 OH_VideoProcessing_Create(&instance, createType);
380 OH_VideoProcessing_Create(&instance2, createType);
381 OH_VideoProcessing_GetSurface(instance, &window);
382 OH_VideoProcessing_GetSurface(instance2, &window2);
383 auto ret = OH_VideoProcessing_SetSurface(instance, window2);
384 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
385 OH_VideoProcessing_Destroy(instance);
386 OH_VideoProcessing_DeinitializeEnvironment();
387 }
388
389 // set surface with a non nullptr window
390 HWTEST_F(DetailEnhancerVideoNdkUnitTest, set_surface_02, TestSize.Level1)
391 {
392 OH_VideoProcessing_InitializeEnvironment();
393 int createType = 0x4;
394 OH_VideoProcessing* instance = nullptr;
395 OHNativeWindow* window = nullptr;
396 OH_VideoProcessing_Create(&instance, createType);
397 auto ret = OH_VideoProcessing_SetSurface(instance, window);
398 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
399 OH_VideoProcessing_Destroy(instance);
400 OH_VideoProcessing_DeinitializeEnvironment();
401 }
402
403 // get surface nullptr
404 HWTEST_F(DetailEnhancerVideoNdkUnitTest, get_surface_01, TestSize.Level1)
405 {
406 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
407 int createType = 0x4;
408 OH_VideoProcessing* instance = nullptr;
409 OHNativeWindow* window;
410 ret = OH_VideoProcessing_Create(&instance, createType);
411 ret = OH_VideoProcessing_GetSurface(instance, &window);
412 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
413 OH_VideoProcessing_Destroy(instance);
414 OH_VideoProcessing_DeinitializeEnvironment();
415 }
416
417 // set surfaceto a non nullptr window
418 HWTEST_F(DetailEnhancerVideoNdkUnitTest, get_surface_02, TestSize.Level1)
419 {
420 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
421 int createType = 0x4;
422 OH_VideoProcessing* instance = nullptr;
423 auto detailEnhVideo = DetailEnhancerVideo::Create();
424 auto surface = detailEnhVideo->GetInputSurface();
425 OHNativeWindow* window = CreateNativeWindowFromSurface(&surface);
426 ret = OH_VideoProcessing_Create(&instance, createType);
427 OH_AVFormat* parameter = OH_AVFormat_Create();
428 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
429 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
430 ret = OH_VideoProcessing_SetParameter(instance, parameter);
431 ret = OH_VideoProcessing_SetSurface(instance, window);
432 ret = OH_VideoProcessing_GetSurface(instance, &window);
433 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
434 OH_VideoProcessing_Destroy(instance);
435 OH_VideoProcessing_DeinitializeEnvironment();
436 }
437
438 // create callback and register
439 HWTEST_F(DetailEnhancerVideoNdkUnitTest, callback_01, TestSize.Level1)
440 {
441 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
442 int createType = 0x4;
443 OH_VideoProcessing* instance = nullptr;
444 OH_VideoProcessing_Create(&instance, createType);
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_HIGH);
448 OH_VideoProcessing_SetParameter(instance, parameter);
449 VideoProcessing_Callback* callback = nullptr;
450 ret = OH_VideoProcessingCallback_Create(&callback);
451 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
452 ret = OH_VideoProcessingCallback_BindOnError(callback, OnError);
453 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
454 ret = OH_VideoProcessingCallback_BindOnState(callback, OnState);
455 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
456 OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
457 OH_VideoProcessing_RenderOutputBuffer(instance, 0);
458 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
459 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
460 OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
461 OH_VideoProcessing_Destroy(instance);
462 OH_VideoProcessing_DeinitializeEnvironment();
463 }
464
465 // create callback and register null func
466 HWTEST_F(DetailEnhancerVideoNdkUnitTest, callback_02, TestSize.Level1)
467 {
468 OH_VideoProcessing_InitializeEnvironment();
469 int createType = 0x4;
470 OH_VideoProcessing* instance = nullptr;
471 OH_VideoProcessing_Create(&instance, createType);
472 OH_AVFormat* parameter = OH_AVFormat_Create();
473 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
474 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
475 OH_VideoProcessing_SetParameter(instance, parameter);
476 VideoProcessing_Callback* callback = nullptr;
477 OH_VideoProcessingCallback_Create(&callback);
478 OH_VideoProcessingCallback_BindOnError(callback, nullptr);
479 OH_VideoProcessingCallback_BindOnState(callback, nullptr);
480 OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, nullptr);
481 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
482 auto ret = OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
483 OH_VideoProcessing_RenderOutputBuffer(instance, 0);
484 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
485 OH_VideoProcessing_Destroy(instance);
486 OH_VideoProcessing_DeinitializeEnvironment();
487 OH_VideoProcessingCallback_Destroy(callback);
488 }
489
490 // create and destroy
491 HWTEST_F(DetailEnhancerVideoNdkUnitTest, callback_03, TestSize.Level1)
492 {
493 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
494 int createType = 0x4;
495 OH_VideoProcessing* instance = nullptr;
496 ret = OH_VideoProcessing_Create(&instance, createType);
497 OH_AVFormat* parameter = OH_AVFormat_Create();
498 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
499 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
500 ret = OH_VideoProcessing_SetParameter(instance, parameter);
501 VideoProcessing_Callback* callback = nullptr;
502 ret = OH_VideoProcessingCallback_Create(&callback);
503 ret = OH_VideoProcessingCallback_BindOnError(callback, OnError);
504 ret = OH_VideoProcessingCallback_BindOnState(callback, OnState);
505 OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
506 void* userData = nullptr;
507 ret = OH_VideoProcessing_RegisterCallback(instance, callback, userData);
508 OH_VideoProcessing_RenderOutputBuffer(instance, 0);
509 ret = OH_VideoProcessingCallback_Destroy(callback);
510 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
511 OH_VideoProcessing_Destroy(instance);
512 OH_VideoProcessing_DeinitializeEnvironment();
513 }
514
515 // only destroy call back
516 HWTEST_F(DetailEnhancerVideoNdkUnitTest, callback_04, TestSize.Level1)
517 {
518 VideoProcessing_Callback* callback = nullptr;
519 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Destroy(callback);
520 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
521 }
522
523 // create callback and register but instance is nullptr
524 HWTEST_F(DetailEnhancerVideoNdkUnitTest, callback_05, TestSize.Level1)
525 {
526 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
527 OH_VideoProcessing* instance = nullptr;
528 VideoProcessing_Callback* callback = nullptr;
529 ret = OH_VideoProcessingCallback_Create(&callback);
530 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
531 ret = OH_VideoProcessingCallback_BindOnError(callback, OnError);
532 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
533 ret = OH_VideoProcessingCallback_BindOnState(callback, OnState);
534 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
535 OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
536 EXPECT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
537 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
538 OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
539 OH_VideoProcessing_RenderOutputBuffer(instance, 0);
540 OH_VideoProcessing_Destroy(instance);
541 OH_VideoProcessing_DeinitializeEnvironment();
542 }
543
544 // create callback and register but callback is nullptr
545 HWTEST_F(DetailEnhancerVideoNdkUnitTest, callback_06, TestSize.Level1)
546 {
547 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
548 int createType = 0x4;
549 OH_VideoProcessing* instance = nullptr;
550 ret = OH_VideoProcessing_Create(&instance, createType);
551 VideoProcessing_Callback* callback = nullptr;
552 ret = OH_VideoProcessingCallback_BindOnError(callback, OnError);
553 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
554 ret = OH_VideoProcessingCallback_BindOnState(callback, OnState);
555 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
556 OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
557 EXPECT_NE(ret, VIDEO_PROCESSING_SUCCESS);
558 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
559 OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
560 OH_VideoProcessing_RenderOutputBuffer(instance, 0);
561 OH_VideoProcessing_Destroy(instance);
562 OH_VideoProcessing_DeinitializeEnvironment();
563 }
564
565 // start processing with flush surface
566 HWTEST_F(DetailEnhancerVideoNdkUnitTest, start_01, TestSize.Level1)
567 {
568 OHNativeWindowBuffer *ohNativeWindowBuffer;
569 OH_VideoProcessing_InitializeEnvironment();
570 int createType = 0x4;
571 OH_VideoProcessing* instance = nullptr;
572 OH_VideoProcessing* instance2 = nullptr;
573 OH_VideoProcessing_Create(&instance, createType);
574 OH_VideoProcessing_Create(&instance2, createType);
575 VideoProcessing_Callback* callback = nullptr;
576 OH_VideoProcessingCallback_Create(&callback);
577 OH_VideoProcessingCallback_BindOnError(callback, OnError);
578 OH_VideoProcessingCallback_BindOnState(callback, OnState);
579 OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
580 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
581 OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
582 OH_AVFormat* parameter = OH_AVFormat_Create();
583 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
584 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
585 OH_VideoProcessing_SetParameter(instance, parameter);
586
587 OHNativeWindow* window = nullptr;
588 OHNativeWindow* window2 = nullptr;
589
590 VideoProcessing_ErrorCode res = OH_VideoProcessing_GetSurface(instance, &window);
591 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
592 res = OH_VideoProcessing_GetSurface(instance2, &window2);
593 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
594 res = OH_VideoProcessing_SetSurface(instance, window2);
595 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
596
597 res = OH_VideoProcessing_Start(instance);
598 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
599 OH_VideoProcessing_RenderOutputBuffer(instance, 0);
600 int fenceFd = -1;
601 auto ret1 = OH_NativeWindow_NativeWindowHandleOpt(window, SET_FORMAT, GRAPHIC_PIXEL_FMT_YCBCR_420_SP);
602 ASSERT_EQ(ret1, VPE_ALGO_ERR_OK);
603 auto ret2 = OH_NativeWindow_NativeWindowHandleOpt(window, SET_BUFFER_GEOMETRY, DEFAULT_WIDTH, DEFAULT_HEIGHT);
604 ASSERT_EQ(ret2, VPE_ALGO_ERR_OK);
605 auto ret3 = OH_NativeWindow_NativeWindowRequestBuffer(window, &ohNativeWindowBuffer, &fenceFd);
606 ASSERT_EQ(ret3, VPE_ALGO_ERR_OK);
607 auto ret4 = FlushSurf(ohNativeWindowBuffer, window);
608 ASSERT_EQ(ret4, VPE_ALGO_ERR_OK);
609 OH_VideoProcessing_RenderOutputBuffer(instance, 1);
610 }
611
612 // start processing with flush surface then stop
613 HWTEST_F(DetailEnhancerVideoNdkUnitTest, start_02, TestSize.Level1)
614 {
615 OHNativeWindowBuffer *ohNativeWindowBuffer;
616 OH_VideoProcessing_InitializeEnvironment();
617 int createType = 0x4;
618 OH_VideoProcessing* instance = nullptr;
619 OH_VideoProcessing* instance2 = nullptr;
620 OH_VideoProcessing_Create(&instance, createType);
621 OH_VideoProcessing_Create(&instance2, createType);
622 VideoProcessing_Callback* callback = nullptr;
623 OH_VideoProcessingCallback_Create(&callback);
624 OH_VideoProcessingCallback_BindOnError(callback, OnError);
625 OH_VideoProcessingCallback_BindOnState(callback, OnState);
626 OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
627 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
628 OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
629 OH_AVFormat* parameter = OH_AVFormat_Create();
630 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
631 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
632 OH_VideoProcessing_SetParameter(instance, parameter);
633
634 OHNativeWindow* window = nullptr;
635 OHNativeWindow* window2 = nullptr;
636
637 VideoProcessing_ErrorCode res = OH_VideoProcessing_GetSurface(instance, &window);
638 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
639 res = OH_VideoProcessing_GetSurface(instance2, &window2);
640 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
641 res = OH_VideoProcessing_SetSurface(instance, window2);
642 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
643
644 res = OH_VideoProcessing_Start(instance);
645 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
646 OH_VideoProcessing_RenderOutputBuffer(instance, 0);
647
648 int fenceFd = -1;
649 auto ret1 = OH_NativeWindow_NativeWindowHandleOpt(window, SET_FORMAT, GRAPHIC_PIXEL_FMT_YCBCR_420_SP);
650 ASSERT_EQ(ret1, VPE_ALGO_ERR_OK);
651 auto ret2 = OH_NativeWindow_NativeWindowHandleOpt(window, SET_BUFFER_GEOMETRY, DEFAULT_WIDTH, DEFAULT_HEIGHT);
652 ASSERT_EQ(ret2, VPE_ALGO_ERR_OK);
653 auto ret3 = OH_NativeWindow_NativeWindowRequestBuffer(window, &ohNativeWindowBuffer, &fenceFd);
654 ASSERT_EQ(ret3, VPE_ALGO_ERR_OK);
655 auto ret4 = FlushSurf(ohNativeWindowBuffer, window);
656 ASSERT_EQ(ret4, VPE_ALGO_ERR_OK);
657
658 OH_VideoProcessing_Stop(instance);
659 WaitForStop();
660 OH_VideoProcessingCallback_Destroy(callback);
661 OH_VideoProcessing_Destroy(instance);
662 OH_VideoProcessing_DeinitializeEnvironment();
663 }
664
665 // start repeatedly
666 HWTEST_F(DetailEnhancerVideoNdkUnitTest, start_03, TestSize.Level1)
667 {
668 OHNativeWindowBuffer *ohNativeWindowBuffer;
669 OH_VideoProcessing_InitializeEnvironment();
670 int createType = 0x4;
671 OH_VideoProcessing* instance = nullptr;
672 OH_VideoProcessing* instance2 = nullptr;
673 OH_VideoProcessing_Create(&instance, createType);
674 OH_VideoProcessing_Create(&instance2, createType);
675 VideoProcessing_Callback* callback = nullptr;
676 OH_VideoProcessingCallback_Create(&callback);
677 OH_VideoProcessingCallback_BindOnError(callback, OnError);
678 OH_VideoProcessingCallback_BindOnState(callback, OnState);
679 OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
680 void* userData = nullptr;
681 OH_VideoProcessing_RegisterCallback(instance, callback, userData);
682 OH_AVFormat* parameter = OH_AVFormat_Create();
683 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
684 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
685 OH_VideoProcessing_SetParameter(instance, parameter);
686
687 OHNativeWindow* window = nullptr;
688 OHNativeWindow* window2 = nullptr;
689
690 VideoProcessing_ErrorCode res = OH_VideoProcessing_GetSurface(instance, &window);
691 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
692 res = OH_VideoProcessing_GetSurface(instance2, &window2);
693 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
694 res = OH_VideoProcessing_SetSurface(instance, window2);
695 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
696
697 res = OH_VideoProcessing_Start(instance);
698 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
699 res = OH_VideoProcessing_Start(instance);
700 EXPECT_NE(res, VIDEO_PROCESSING_SUCCESS);
701
702 int fenceFd = -1;
703 auto ret1 = OH_NativeWindow_NativeWindowHandleOpt(window, SET_FORMAT, GRAPHIC_PIXEL_FMT_YCBCR_420_SP);
704 ASSERT_EQ(ret1, VPE_ALGO_ERR_OK);
705 auto ret2 = OH_NativeWindow_NativeWindowHandleOpt(window, SET_BUFFER_GEOMETRY, DEFAULT_WIDTH, DEFAULT_HEIGHT);
706 ASSERT_EQ(ret2, VPE_ALGO_ERR_OK);
707 auto ret3 = OH_NativeWindow_NativeWindowRequestBuffer(window, &ohNativeWindowBuffer, &fenceFd);
708 ASSERT_EQ(ret3, VPE_ALGO_ERR_OK);
709 auto ret4 = FlushSurf(ohNativeWindowBuffer, window);
710 ASSERT_EQ(ret4, VPE_ALGO_ERR_OK);
711 OH_VideoProcessing_RenderOutputBuffer(instance, 0);
712
713 OH_VideoProcessing_Stop(instance);
714 WaitForStop();
715 OH_VideoProcessing_Stop(instance);
716 OH_VideoProcessingCallback_Destroy(callback);
717 OH_VideoProcessing_Destroy(instance);
718 OH_VideoProcessing_DeinitializeEnvironment();
719 }
720
721 // start but not have buffer callbacks
722 HWTEST_F(DetailEnhancerVideoNdkUnitTest, start_04, TestSize.Level1)
723 {
724 OHNativeWindowBuffer *ohNativeWindowBuffer;
725 OH_VideoProcessing_InitializeEnvironment();
726 int createType = 0x4;
727 OH_VideoProcessing* instance = nullptr;
728 OH_VideoProcessing* instance2 = nullptr;
729 OH_VideoProcessing_Create(&instance, createType);
730 OH_VideoProcessing_Create(&instance2, createType);
731 VideoProcessing_Callback* callback = nullptr;
732 OH_VideoProcessingCallback_Create(&callback);
733 OH_VideoProcessingCallback_BindOnError(callback, OnError);
734 OH_VideoProcessingCallback_BindOnState(callback, OnState);
735 OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, nullptr);
736 void* userData = nullptr;
737 OH_VideoProcessing_RegisterCallback(instance, callback, userData);
738 OH_AVFormat* parameter = OH_AVFormat_Create();
739 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
740 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
741 OH_VideoProcessing_SetParameter(instance, parameter);
742
743 OHNativeWindow* window = nullptr;
744 OHNativeWindow* window2 = nullptr;
745
746 VideoProcessing_ErrorCode res = OH_VideoProcessing_GetSurface(instance, &window);
747 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
748 res = OH_VideoProcessing_GetSurface(instance2, &window2);
749 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
750 res = OH_VideoProcessing_SetSurface(instance, window2);
751 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
752
753 res = OH_VideoProcessing_Start(instance);
754 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
755
756 int fenceFd = -1;
757 auto ret1 = OH_NativeWindow_NativeWindowHandleOpt(window, SET_FORMAT, GRAPHIC_PIXEL_FMT_YCBCR_420_SP);
758 ASSERT_EQ(ret1, VPE_ALGO_ERR_OK);
759 auto ret2 = OH_NativeWindow_NativeWindowHandleOpt(window, SET_BUFFER_GEOMETRY, DEFAULT_WIDTH, DEFAULT_HEIGHT);
760 ASSERT_EQ(ret2, VPE_ALGO_ERR_OK);
761 auto ret3 = OH_NativeWindow_NativeWindowRequestBuffer(window, &ohNativeWindowBuffer, &fenceFd);
762 ASSERT_EQ(ret3, VPE_ALGO_ERR_OK);
763 auto ret4 = FlushSurf(ohNativeWindowBuffer, window);
764 ASSERT_EQ(ret4, VPE_ALGO_ERR_OK);
765 OH_VideoProcessing_RenderOutputBuffer(instance, 0);
766
767 OH_VideoProcessing_Stop(instance);
768 WaitForStop();
769 OH_VideoProcessingCallback_Destroy(callback);
770 OH_VideoProcessing_Destroy(instance);
771 OH_VideoProcessing_DeinitializeEnvironment();
772 }
773
774 // start and destroy while still running
775 HWTEST_F(DetailEnhancerVideoNdkUnitTest, start_05, TestSize.Level1)
776 {
777 OHNativeWindowBuffer *ohNativeWindowBuffer;
778 OH_VideoProcessing_InitializeEnvironment();
779 int createType = 0x4;
780 OH_VideoProcessing* instance = nullptr;
781 OH_VideoProcessing* instance2 = nullptr;
782 OH_VideoProcessing_Create(&instance, createType);
783 OH_VideoProcessing_Create(&instance2, createType);
784 VideoProcessing_Callback* callback = nullptr;
785 OH_VideoProcessingCallback_Create(&callback);
786 OH_VideoProcessingCallback_BindOnError(callback, OnError);
787 OH_VideoProcessingCallback_BindOnState(callback, OnState);
788 OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
789 void* userData = nullptr;
790 OH_VideoProcessing_RegisterCallback(instance, callback, userData);
791 OH_AVFormat* parameter = OH_AVFormat_Create();
792 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
793 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
794 OH_VideoProcessing_SetParameter(instance, parameter);
795
796 OHNativeWindow* window = nullptr;
797 OHNativeWindow* window2 = nullptr;
798
799 VideoProcessing_ErrorCode res = OH_VideoProcessing_GetSurface(instance, &window);
800 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
801 res = OH_VideoProcessing_GetSurface(instance2, &window2);
802 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
803 res = OH_VideoProcessing_SetSurface(instance, window2);
804 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
805
806 res = OH_VideoProcessing_Start(instance);
807 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
808
809 int fenceFd = -1;
810 auto ret1 = OH_NativeWindow_NativeWindowHandleOpt(window, SET_FORMAT, GRAPHIC_PIXEL_FMT_YCBCR_420_SP);
811 ASSERT_EQ(ret1, VPE_ALGO_ERR_OK);
812 auto ret2 = OH_NativeWindow_NativeWindowHandleOpt(window, SET_BUFFER_GEOMETRY, DEFAULT_WIDTH, DEFAULT_HEIGHT);
813 ASSERT_EQ(ret2, VPE_ALGO_ERR_OK);
814 auto ret3 = OH_NativeWindow_NativeWindowRequestBuffer(window, &ohNativeWindowBuffer, &fenceFd);
815 ASSERT_EQ(ret3, VPE_ALGO_ERR_OK);
816 auto ret4 = FlushSurf(ohNativeWindowBuffer, window);
817 ASSERT_EQ(ret4, VPE_ALGO_ERR_OK);
818 OH_VideoProcessing_RenderOutputBuffer(instance, 0);
819 res = OH_VideoProcessingCallback_Destroy(callback);
820 EXPECT_NE(res, VIDEO_PROCESSING_SUCCESS);
821 res = OH_VideoProcessingCallback_Destroy(nullptr);
822 EXPECT_NE(res, VIDEO_PROCESSING_SUCCESS);
823
824 OH_VideoProcessing_Stop(instance);
825 WaitForStop();
826 OH_VideoProcessingCallback_Destroy(callback);
827 OH_VideoProcessing_Destroy(instance);
828 OH_VideoProcessing_DeinitializeEnvironment();
829 }
830
831 // start but no callbacks binded
832 HWTEST_F(DetailEnhancerVideoNdkUnitTest, start_06, TestSize.Level1)
833 {
834 OHNativeWindowBuffer *ohNativeWindowBuffer;
835 OH_VideoProcessing_InitializeEnvironment();
836 int createType = 0x4;
837 OH_VideoProcessing* instance = nullptr;
838 OH_VideoProcessing* instance2 = nullptr;
839 OH_VideoProcessing_Create(&instance, createType);
840 OH_VideoProcessing_Create(&instance2, createType);
841 VideoProcessing_Callback* callback = nullptr;
842 OH_VideoProcessingCallback_Create(&callback);
843 void* userData = nullptr;
844 OH_VideoProcessing_RegisterCallback(instance, callback, userData);
845 OH_AVFormat* parameter = OH_AVFormat_Create();
846 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
847 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
848 OH_VideoProcessing_SetParameter(instance, parameter);
849
850 OHNativeWindow* window = nullptr;
851 OHNativeWindow* window2 = nullptr;
852
853 VideoProcessing_ErrorCode res = OH_VideoProcessing_GetSurface(instance, &window);
854 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
855 res = OH_VideoProcessing_GetSurface(instance2, &window2);
856 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
857 res = OH_VideoProcessing_SetSurface(instance, window2);
858 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
859
860 res = OH_VideoProcessing_Start(instance);
861 EXPECT_NE(res, VIDEO_PROCESSING_SUCCESS);
862
863 int fenceFd = -1;
864 auto ret1 = OH_NativeWindow_NativeWindowHandleOpt(window, SET_FORMAT, GRAPHIC_PIXEL_FMT_YCBCR_420_SP);
865 ASSERT_EQ(ret1, VPE_ALGO_ERR_OK);
866 auto ret2 = OH_NativeWindow_NativeWindowHandleOpt(window, SET_BUFFER_GEOMETRY, DEFAULT_WIDTH, DEFAULT_HEIGHT);
867 ASSERT_EQ(ret2, VPE_ALGO_ERR_OK);
868 auto ret3 = OH_NativeWindow_NativeWindowRequestBuffer(window, &ohNativeWindowBuffer, &fenceFd);
869 ASSERT_EQ(ret3, VPE_ALGO_ERR_OK);
870 auto ret4 = FlushSurf(ohNativeWindowBuffer, window);
871 ASSERT_EQ(ret4, VPE_ALGO_ERR_OK);
872 OH_VideoProcessing_RenderOutputBuffer(instance, 1);
873
874 OH_VideoProcessing_Stop(instance);
875 WaitForStop();
876 OH_VideoProcessingCallback_Destroy(callback);
877 OH_VideoProcessing_Destroy(instance);
878 OH_VideoProcessing_DeinitializeEnvironment();
879 }
880
881 // start processing with flush surface then stop and start again
882 HWTEST_F(DetailEnhancerVideoNdkUnitTest, start_07, TestSize.Level1)
883 {
884 OHNativeWindowBuffer *ohNativeWindowBuffer;
885 OH_VideoProcessing_InitializeEnvironment();
886 int createType = 0x4;
887 OH_VideoProcessing* instance = nullptr;
888 OH_VideoProcessing* instance2 = nullptr;
889 OH_VideoProcessing_Create(&instance, createType);
890 OH_VideoProcessing_Create(&instance2, createType);
891 VideoProcessing_Callback* callback = nullptr;
892 OH_VideoProcessingCallback_Create(&callback);
893 OH_VideoProcessingCallback_BindOnError(callback, OnError);
894 OH_VideoProcessingCallback_BindOnState(callback, OnState);
895 OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBuffer);
896 auto userData = VIDEO_PROCESSING_STATE_STOPPED;
897 OH_VideoProcessing_RegisterCallback(instance, callback, &userData);
898 OH_AVFormat* parameter = OH_AVFormat_Create();
899 OH_AVFormat_SetIntValue(parameter, VIDEO_DETAIL_ENHANCER_PARAMETER_KEY_QUALITY_LEVEL,
900 VIDEO_DETAIL_ENHANCER_QUALITY_LEVEL_HIGH);
901 OH_VideoProcessing_SetParameter(instance, parameter);
902
903 OHNativeWindow* window = nullptr;
904 OHNativeWindow* window2 = nullptr;
905
906 VideoProcessing_ErrorCode res = OH_VideoProcessing_GetSurface(instance, &window);
907 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
908 res = OH_VideoProcessing_GetSurface(instance2, &window2);
909 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
910 res = OH_VideoProcessing_SetSurface(instance, window2);
911 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
912
913 res = OH_VideoProcessing_Start(instance);
914 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
915 OH_VideoProcessing_RenderOutputBuffer(instance, 0);
916
917 int fenceFd = -1;
918 auto ret1 = OH_NativeWindow_NativeWindowHandleOpt(window, SET_FORMAT, GRAPHIC_PIXEL_FMT_YCBCR_420_SP);
919 ASSERT_EQ(ret1, VPE_ALGO_ERR_OK);
920 auto ret2 = OH_NativeWindow_NativeWindowHandleOpt(window, SET_BUFFER_GEOMETRY, DEFAULT_WIDTH, DEFAULT_HEIGHT);
921 ASSERT_EQ(ret2, VPE_ALGO_ERR_OK);
922 auto ret3 = OH_NativeWindow_NativeWindowRequestBuffer(window, &ohNativeWindowBuffer, &fenceFd);
923 ASSERT_EQ(ret3, VPE_ALGO_ERR_OK);
924 auto ret4 = FlushSurf(ohNativeWindowBuffer, window);
925 ASSERT_EQ(ret4, VPE_ALGO_ERR_OK);
926
927 OH_VideoProcessing_Stop(instance);
928 WaitForStop();
929 res = OH_VideoProcessing_Start(instance);
930 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
931 FlushSurf(ohNativeWindowBuffer, window);
932 OH_VideoProcessing_Stop(instance);
933 WaitForStop();
934 OH_VideoProcessingCallback_Destroy(callback);
935 OH_VideoProcessing_Destroy(instance);
936 OH_VideoProcessing_DeinitializeEnvironment();
937 }
938
939 // simple output buffer check
940 HWTEST_F(DetailEnhancerVideoNdkUnitTest, output_buffer_1, TestSize.Level1)
941 {
942 OH_VideoProcessing_InitializeEnvironment();
943 int createType = 0x4;
944 OH_VideoProcessing* instance = nullptr;
945 auto res = OH_VideoProcessing_Create(&instance, createType);
946 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
947 OH_VideoProcessing_RenderOutputBuffer(instance, 0);
948 res = OH_VideoProcessing_Destroy(instance);
949 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
950 res = OH_VideoProcessing_DeinitializeEnvironment();
951 EXPECT_EQ(res, VIDEO_PROCESSING_SUCCESS);
952 }
953
954 } // namespace VideoProcessingEngine
955 } // namespace Media
956 } // namespace OHOS
957