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 <iostream>
16 #include <atomic>
17 #include <fstream>
18 #include <thread>
19 #include <queue>
20 #include <string>
21 #include "gtest/gtest.h"
22 #include "video_processing.h"
23 #include "surface/native_buffer.h"
24 #include "iconsumer_surface.h"
25 #include "surface/window.h"
26 #include "nocopyable.h"
27 using namespace std;
28 using namespace OHOS;
29 using namespace testing::ext;
30 namespace {
31 class VpeVideoApiTest : public testing::Test {
32 public:
33     // SetUpTestCase: Called before all test cases
34     static void SetUpTestCase(void);
35     // TearDownTestCase: Called after all test case
36     static void TearDownTestCase(void);
37     // SetUp: Called before each test cases
38     void SetUp(void);
39     // TearDown: Called after each test cases
40     void TearDown(void);
41 };
42 
43 class TestConsumerListener : public IBufferConsumerListener {
44 public:
45     TestConsumerListener(sptr<Surface> cs, std::string_view name);
46     ~TestConsumerListener();
47     void OnBufferAvailable() override;
48 };
49 
SetUpTestCase()50 void VpeVideoApiTest::SetUpTestCase() {}
TearDownTestCase()51 void VpeVideoApiTest::TearDownTestCase() {}
SetUp()52 void VpeVideoApiTest::SetUp() {}
TearDown()53 void VpeVideoApiTest::TearDown()
54 {
55     OH_VideoProcessing_DeinitializeEnvironment();
56 }
57 
TestConsumerListener(sptr<Surface> cs,std::string_view name)58 TestConsumerListener::TestConsumerListener(sptr<Surface> cs, std::string_view name) {}
59 
~TestConsumerListener()60 TestConsumerListener::~TestConsumerListener() {}
61 
OnBufferAvailable()62 void TestConsumerListener::OnBufferAvailable() {}
63 
64 const VideoProcessing_ColorSpaceInfo SRC_INFO = {OH_VIDEO_HDR_VIVID,
65                                                  OH_COLORSPACE_BT2020_HLG_LIMIT,
66                                                  NATIVEBUFFER_PIXEL_FMT_YCBCR_P010};
67 const VideoProcessing_ColorSpaceInfo DST_INFO = {OH_VIDEO_HDR_VIVID,
68                                                  OH_COLORSPACE_BT2020_PQ_LIMIT,
69                                                  NATIVEBUFFER_PIXEL_FMT_YCBCR_P010};
70 
71 }
72 
73 namespace {
74 static int32_t g_userValue = 1;
75 static int32_t g_index = 1;
76 
onErrorEmptyCallback(OH_VideoProcessing * videoProcessor,VideoProcessing_ErrorCode error,void * userData)77 static void onErrorEmptyCallback(OH_VideoProcessing* videoProcessor, VideoProcessing_ErrorCode error,
78     void* userData)
79 {
80     //do nothing
81 }
82 
onErrorCallback(OH_VideoProcessing * videoProcessor,VideoProcessing_ErrorCode error,void * userData)83 static void onErrorCallback(OH_VideoProcessing* videoProcessor, VideoProcessing_ErrorCode error,
84     void* userData)
85 {
86     cout << "onErrorCallback" << endl;
87 }
88 
onStateEmptyCallback(OH_VideoProcessing * videoProcessor,VideoProcessing_State state,void * userData)89 static void onStateEmptyCallback(OH_VideoProcessing* videoProcessor, VideoProcessing_State state,
90     void* userData)
91 {
92     //do nothing
93 }
94 
onStateCallback(OH_VideoProcessing * videoProcessor,VideoProcessing_State state,void * userData)95 static void onStateCallback(OH_VideoProcessing* videoProcessor, VideoProcessing_State state,
96     void* userData)
97 {
98     cout << "onStateCallback" << endl;
99 }
100 
101 
OnNewOutputBufferEmptyCallback(OH_VideoProcessing * videoProcessor,uint32_t index,void * userData)102 static void OnNewOutputBufferEmptyCallback(OH_VideoProcessing* videoProcessor, uint32_t index,
103     void* userData)
104 {
105     //do nothing
106 }
107 
OnNewOutputBufferCallback(OH_VideoProcessing * videoProcessor,uint32_t index,void * userData)108 static void OnNewOutputBufferCallback(OH_VideoProcessing* videoProcessor, uint32_t index,
109     void* userData)
110 {
111     cout << "OnNewOutputBufferCallback" << endl;
112 }
113 
114 /**
115  * @tc.number    : VPE_VIDEO_API_TEST_0010
116  * @tc.name      : first call OH_VideoProcessing_InitializeEnvironment
117  * @tc.desc      : function test
118  */
119 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0010, TestSize.Level0)
120 {
121     VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
122     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
123     OH_VideoProcessing_DeinitializeEnvironment();
124 }
125 
126 /**
127  * @tc.number    : VPE_VIDEO_API_TEST_0020
128  * @tc.name      : first call OH_VideoProcessing_DeinitializeEnvironment
129  * @tc.desc      : function test
130  */
131 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0020, TestSize.Level0)
132 {
133     VideoProcessing_ErrorCode ret = OH_VideoProcessing_DeinitializeEnvironment();
134     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
135 }
136 
137 /**
138  * @tc.number    : VPE_VIDEO_API_TEST_0030
139  * @tc.name      : call OH_VideoProcessing_DeinitializeEnvironment after initialize
140  * @tc.desc      : function test
141  */
142 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0030, TestSize.Level0)
143 {
144     VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
145     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
146     ret = OH_VideoProcessing_DeinitializeEnvironment();
147     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
148 }
149 
150 /**
151  * @tc.number    : VPE_VIDEO_API_TEST_0040
152  * @tc.name      : call OH_VideoProcessing_IsColorSpaceConversionSupported with nullptr,nullptr
153  * @tc.desc      : function test
154  */
155 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0040, TestSize.Level0)
156 {
157     OH_VideoProcessing_InitializeEnvironment();
158     bool ret = OH_VideoProcessing_IsColorSpaceConversionSupported(nullptr, nullptr);
159     ASSERT_FALSE(ret);
160     OH_VideoProcessing_DeinitializeEnvironment();
161 }
162 
163 /**
164  * @tc.number    : VPE_VIDEO_API_TEST_0050
165  * @tc.name      : call OH_VideoProcessing_IsColorSpaceConversionSupported
166  * @tc.desc      : function test
167  */
168 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0050, TestSize.Level0)
169 {
170     OH_VideoProcessing_InitializeEnvironment();
171     bool ret = OH_VideoProcessing_IsColorSpaceConversionSupported(&SRC_INFO, nullptr);
172     ASSERT_FALSE(ret);
173 }
174 
175 /**
176  * @tc.number    : VPE_VIDEO_API_TEST_0060
177  * @tc.name      : call OH_VideoProcessing_IsColorSpaceConversionSupported
178  * @tc.desc      : function test
179  */
180 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0060, TestSize.Level0)
181 {
182     OH_VideoProcessing_InitializeEnvironment();
183     bool ret = OH_VideoProcessing_IsColorSpaceConversionSupported(nullptr, &DST_INFO);
184     ASSERT_FALSE(ret);
185 }
186 
187 /**
188  * @tc.number    : VPE_VIDEO_API_TEST_0070
189  * @tc.name      : call OH_VideoProcessing_IsColorSpaceConversionSupported
190  * @tc.desc      : function test
191  */
192 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0070, TestSize.Level0)
193 {
194     OH_VideoProcessing_InitializeEnvironment();
195     bool ret = OH_VideoProcessing_IsColorSpaceConversionSupported(&SRC_INFO, &DST_INFO);
196     if (!access("/system/lib64/", 0)) {
197         ASSERT_TRUE(ret);
198     } else {
199         ASSERT_FALSE(ret);
200     }
201 }
202 
203 /**
204  * @tc.number    : VPE_VIDEO_API_TEST_0080
205  * @tc.name      : call OH_VideoProcessing_IsMetadataGenerationSupported
206  * @tc.desc      : function test
207  */
208 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0080, TestSize.Level0)
209 {
210     OH_VideoProcessing_InitializeEnvironment();
211     bool ret = OH_VideoProcessing_IsMetadataGenerationSupported(nullptr);
212     ASSERT_FALSE(ret);
213 }
214 
215 /**
216  * @tc.number    : VPE_VIDEO_API_TEST_0090
217  * @tc.name      : call OH_VideoProcessing_IsMetadataGenerationSupported
218  * @tc.desc      : function test
219  */
220 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0090, TestSize.Level0)
221 {
222     OH_VideoProcessing_InitializeEnvironment();
223     bool ret = OH_VideoProcessing_IsMetadataGenerationSupported(&SRC_INFO);
224     if (!access("/system/lib64/", 0)) {
225         ASSERT_TRUE(ret);
226     } else {
227         ASSERT_FALSE(ret);
228     }
229 }
230 
231 /**
232  * @tc.number    : VPE_VIDEO_API_TEST_0100
233  * @tc.name      : call OH_VideoProcessing_Create
234  * @tc.desc      : function test
235  */
236 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0100, TestSize.Level0)
237 {
238     OH_VideoProcessing_InitializeEnvironment();
239     OH_VideoProcessing** videoProcessor = nullptr;
240     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(videoProcessor, INT_MAX);
241     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
242 }
243 
244 /**
245  * @tc.number    : VPE_VIDEO_API_TEST_0110
246  * @tc.name      : call OH_VideoProcessing_Create
247  * @tc.desc      : function test
248  */
249 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0110, TestSize.Level0)
250 {
251     OH_VideoProcessing_InitializeEnvironment();
252     OH_VideoProcessing** videoProcessor = nullptr;
253     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(videoProcessor,
254         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
255     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
256 }
257 
258 /**
259  * @tc.number    : VPE_VIDEO_API_TEST_0120
260  * @tc.name      : call OH_VideoProcessing_Create
261  * @tc.desc      : function test
262  */
263 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0120, TestSize.Level0)
264 {
265     OH_VideoProcessing_InitializeEnvironment();
266     OH_VideoProcessing* videoProcessor = nullptr;
267     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor, INT_MAX);
268     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
269     OH_VideoProcessing_Destroy(videoProcessor);
270 }
271 
272 /**
273  * @tc.number    : VPE_VIDEO_API_TEST_0130
274  * @tc.name      : call OH_VideoProcessing_Create
275  * @tc.desc      : function test
276  */
277 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0130, TestSize.Level0)
278 {
279     OH_VideoProcessing_InitializeEnvironment();
280     OH_VideoProcessing* videoProcessor = nullptr;
281     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
282         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
283     if (!access("/system/lib64/", 0)) {
284         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
285         OH_VideoProcessing_Destroy(videoProcessor);
286     } else {
287         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
288     }
289 }
290 
291 /**
292  * @tc.number    : VPE_VIDEO_API_TEST_0140
293  * @tc.name      : call OH_VideoProcessing_Destroy
294  * @tc.desc      : function test
295  */
296 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0140, TestSize.Level0)
297 {
298     OH_VideoProcessing_InitializeEnvironment();
299     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Destroy(nullptr);
300     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
301 }
302 
303 /**
304  * @tc.number    : VPE_VIDEO_API_TEST_0150
305  * @tc.name      : call OH_VideoProcessing_Destroy
306  * @tc.desc      : function test
307  */
308 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0150, TestSize.Level0)
309 {
310     OH_VideoProcessing_InitializeEnvironment();
311     OH_VideoProcessing* videoProcessor = nullptr;
312     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
313         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
314     if (!access("/system/lib64/", 0)) {
315         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
316         ret = OH_VideoProcessing_Destroy(videoProcessor);
317         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
318     } else {
319         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
320     }
321 }
322 
323 /**
324  * @tc.number    : VPE_VIDEO_API_TEST_0160
325  * @tc.name      : call OH_VideoProcessing_RegisterCallback
326  * @tc.desc      : function test
327  */
328 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0160, TestSize.Level0)
329 {
330     OH_VideoProcessing_InitializeEnvironment();
331     VideoProcessing_ErrorCode ret = OH_VideoProcessing_RegisterCallback(nullptr, nullptr, nullptr);
332     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
333 }
334 
335 /**
336  * @tc.number    : VPE_VIDEO_API_TEST_0170
337  * @tc.name      : call OH_VideoProcessing_RegisterCallback
338  * @tc.desc      : function test
339  */
340 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0170, TestSize.Level0)
341 {
342     OH_VideoProcessing_InitializeEnvironment();
343     VideoProcessing_Callback* callback = nullptr;
344     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
345     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
346     ret = OH_VideoProcessing_RegisterCallback(nullptr, callback, nullptr);
347     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
348     OH_VideoProcessingCallback_Destroy(callback);
349 }
350 
351 /**
352  * @tc.number    : VPE_VIDEO_API_TEST_0180
353  * @tc.name      : call OH_VideoProcessing_RegisterCallback
354  * @tc.desc      : function test
355  */
356 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0180, TestSize.Level0)
357 {
358     OH_VideoProcessing_InitializeEnvironment();
359     OH_VideoProcessing* videoProcessor = nullptr;
360     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
361         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
362     if (!access("/system/lib64/", 0)) {
363         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
364         ret = OH_VideoProcessing_RegisterCallback(videoProcessor, nullptr, nullptr);
365         ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
366         OH_VideoProcessing_Destroy(videoProcessor);
367     } else {
368         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
369     }
370 }
371 
372 /**
373  * @tc.number    : VPE_VIDEO_API_TEST_0190
374  * @tc.name      : call OH_VideoProcessing_RegisterCallback
375  * @tc.desc      : function test
376  */
377 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0190, TestSize.Level0)
378 {
379     OH_VideoProcessing_InitializeEnvironment();
380     OH_VideoProcessing* videoProcessor = nullptr;
381     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
382         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
383     if (!access("/system/lib64/", 0)) {
384         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
385         VideoProcessing_Callback* callback = nullptr;
386         ret = OH_VideoProcessingCallback_Create(&callback);
387         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
388         ret = OH_VideoProcessingCallback_BindOnError(callback, onErrorEmptyCallback);
389         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
390         ret = OH_VideoProcessing_RegisterCallback(videoProcessor, callback, nullptr);
391         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
392         OH_VideoProcessing_Destroy(videoProcessor);
393         OH_VideoProcessingCallback_Destroy(callback);
394     } else {
395         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
396     }
397 }
398 
399 /**
400  * @tc.number    : VPE_VIDEO_API_TEST_0200
401  * @tc.name      : call OH_VideoProcessing_RegisterCallback
402  * @tc.desc      : function test
403  */
404 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0200, TestSize.Level0)
405 {
406     OH_VideoProcessing_InitializeEnvironment();
407     OH_VideoProcessing* videoProcessor = nullptr;
408     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
409         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
410     if (!access("/system/lib64/", 0)) {
411         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
412         VideoProcessing_Callback* callback = nullptr;
413         ret = OH_VideoProcessingCallback_Create(&callback);
414         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
415         ret = OH_VideoProcessing_RegisterCallback(videoProcessor, callback, nullptr);
416         ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_VALUE);
417         OH_VideoProcessing_Destroy(videoProcessor);
418         OH_VideoProcessingCallback_Destroy(callback);
419     } else {
420         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
421     }
422 }
423 
424 /**
425  * @tc.number    : VPE_VIDEO_API_TEST_0210
426  * @tc.name      : call OH_VideoProcessing_RegisterCallback
427  * @tc.desc      : function test
428  */
429 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0210, TestSize.Level0)
430 {
431     OH_VideoProcessing_InitializeEnvironment();
432     OH_VideoProcessing* videoProcessor = nullptr;
433     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
434         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
435     if (!access("/system/lib64/", 0)) {
436         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
437         VideoProcessing_Callback* callback = nullptr;
438         ret = OH_VideoProcessingCallback_Create(&callback);
439         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
440         void* userData = &g_userValue;
441         if (!userData) {
442             ret = OH_VideoProcessing_RegisterCallback(videoProcessor, callback, userData);
443             ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
444         }
445         OH_VideoProcessing_Destroy(videoProcessor);
446         OH_VideoProcessingCallback_Destroy(callback);
447     } else {
448         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
449     }
450 }
451 
452 /**
453  * @tc.number    : VPE_VIDEO_API_TEST_0220
454  * @tc.name      : call OH_VideoProcessing_SetSurface
455  * @tc.desc      : function test
456  */
457 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0220, TestSize.Level0)
458 {
459     OH_VideoProcessing_InitializeEnvironment();
460     VideoProcessing_ErrorCode ret = OH_VideoProcessing_SetSurface(nullptr, nullptr);
461     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
462 }
463 
464 /**
465  * @tc.number    : VPE_VIDEO_API_TEST_0230
466  * @tc.name      : call OH_VideoProcessing_SetSurface
467  * @tc.desc      : function test
468  */
469 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0230, TestSize.Level0)
470 {
471     OH_VideoProcessing_InitializeEnvironment();
472     sptr<Surface> cs = Surface::CreateSurfaceAsConsumer();
473     sptr<IBufferConsumerListener> listener = new TestConsumerListener(
474         cs, "/data/test/media/out_320_240_10s.rgba");
475     cs->RegisterConsumerListener(listener);
476     auto p = cs->GetProducer();
477     sptr<Surface> ps = Surface::CreateSurfaceAsProducer(p);
478     OHNativeWindow *window = nullptr;
479     window = CreateNativeWindowFromSurface(&ps);
480     VideoProcessing_ErrorCode ret = OH_VideoProcessing_SetSurface(nullptr, window);
481     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
482     OH_NativeWindow_DestroyNativeWindow(window);
483 }
484 
485 /**
486  * @tc.number    : VPE_VIDEO_API_TEST_0240
487  * @tc.name      : call OH_VideoProcessing_SetSurface
488  * @tc.desc      : function test
489  */
490 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0240, TestSize.Level0)
491 {
492     OH_VideoProcessing_InitializeEnvironment();
493     OH_VideoProcessing* videoProcessor = nullptr;
494     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
495         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
496     if (!access("/system/lib64/", 0)) {
497         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
498         ret = OH_VideoProcessing_SetSurface(videoProcessor, nullptr);
499         ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
500         OH_VideoProcessing_Destroy(videoProcessor);
501     } else {
502         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
503     }
504 }
505 
506 /**
507  * @tc.number    : VPE_VIDEO_API_TEST_0250
508  * @tc.name      : call OH_VideoProcessing_SetSurface
509  * @tc.desc      : function test
510  */
511 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0250, TestSize.Level0)
512 {
513     OH_VideoProcessing_InitializeEnvironment();
514     OH_VideoProcessing* videoProcessor = nullptr;
515     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
516         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
517     if (!access("/system/lib64/", 0)) {
518         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
519         sptr<Surface> cs = Surface::CreateSurfaceAsConsumer();
520         sptr<IBufferConsumerListener> listener = new TestConsumerListener(
521             cs, "/data/test/media/out_320_240_10s.rgba");
522         cs->RegisterConsumerListener(listener);
523         auto p = cs->GetProducer();
524         sptr<Surface> ps = Surface::CreateSurfaceAsProducer(p);
525         OHNativeWindow *window = nullptr;
526         window = CreateNativeWindowFromSurface(&ps);
527         ret = OH_VideoProcessing_SetSurface(videoProcessor, window);
528         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
529         OH_VideoProcessing_Destroy(videoProcessor);
530         OH_NativeWindow_DestroyNativeWindow(window);
531     } else {
532         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
533     }
534 }
535 
536 /**
537  * @tc.number    : VPE_VIDEO_API_TEST_0260
538  * @tc.name      : call OH_VideoProcessing_GetSurface
539  * @tc.desc      : function test
540  */
541 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0260, TestSize.Level0)
542 {
543     OH_VideoProcessing_InitializeEnvironment();
544     VideoProcessing_ErrorCode ret = OH_VideoProcessing_GetSurface(nullptr, nullptr);
545     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
546 }
547 
548 /**
549  * @tc.number    : VPE_VIDEO_API_TEST_0270
550  * @tc.name      : call OH_VideoProcessing_GetSurface
551  * @tc.desc      : function test
552  */
553 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0270, TestSize.Level0)
554 {
555     OH_VideoProcessing_InitializeEnvironment();
556     sptr<Surface> cs = Surface::CreateSurfaceAsConsumer();
557     sptr<IBufferConsumerListener> listener = new TestConsumerListener(
558         cs, "/data/test/media/out_320_240_10s.rgba");
559     cs->RegisterConsumerListener(listener);
560     auto p = cs->GetProducer();
561     sptr<Surface> ps = Surface::CreateSurfaceAsProducer(p);
562     OHNativeWindow *window = nullptr;
563     window = CreateNativeWindowFromSurface(&ps);
564     VideoProcessing_ErrorCode ret = OH_VideoProcessing_GetSurface(nullptr, &window);
565     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
566     OH_NativeWindow_DestroyNativeWindow(window);
567 }
568 
569 /**
570  * @tc.number    : VPE_VIDEO_API_TEST_0280
571  * @tc.name      : call OH_VideoProcessing_GetSurface
572  * @tc.desc      : function test
573  */
574 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0280, TestSize.Level0)
575 {
576     OH_VideoProcessing_InitializeEnvironment();
577     OH_VideoProcessing* videoProcessor = nullptr;
578     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
579         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
580     if (!access("/system/lib64/", 0)) {
581         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
582         ret = OH_VideoProcessing_GetSurface(videoProcessor, nullptr);
583         ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
584         OH_VideoProcessing_Destroy(videoProcessor);
585     } else {
586         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
587     }
588 }
589 
590 /**
591  * @tc.number    : VPE_VIDEO_API_TEST_0290
592  * @tc.name      : call OH_VideoProcessing_GetSurface
593  * @tc.desc      : function test
594  */
595 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0290, TestSize.Level0)
596 {
597     OH_VideoProcessing_InitializeEnvironment();
598     OH_VideoProcessing* videoProcessor = nullptr;
599     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
600         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
601     if (!access("/system/lib64/", 0)) {
602         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
603         sptr<Surface> cs = Surface::CreateSurfaceAsConsumer();
604         sptr<IBufferConsumerListener> listener = new TestConsumerListener(
605             cs, "/data/test/media/out_320_240_10s.rgba");
606         cs->RegisterConsumerListener(listener);
607         auto p = cs->GetProducer();
608         sptr<Surface> ps = Surface::CreateSurfaceAsProducer(p);
609         OHNativeWindow *window = nullptr;
610         window = CreateNativeWindowFromSurface(&ps);
611         ret = OH_VideoProcessing_GetSurface(videoProcessor, &window);
612         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
613         OH_VideoProcessing_Destroy(videoProcessor);
614         OH_NativeWindow_DestroyNativeWindow(window);
615     } else {
616         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
617     }
618 }
619 
620 /**
621  * @tc.number    : VPE_VIDEO_API_TEST_0300
622  * @tc.name      : call OH_VideoProcessing_Start
623  * @tc.desc      : function test
624  */
625 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0300, TestSize.Level0)
626 {
627     OH_VideoProcessing_InitializeEnvironment();
628     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Start(nullptr);
629     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
630 }
631 
632 /**
633  * @tc.number    : VPE_VIDEO_API_TEST_0310
634  * @tc.name      : call OH_VideoProcessing_Start
635  * @tc.desc      : function test
636  */
637 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0310, TestSize.Level0)
638 {
639     OH_VideoProcessing_InitializeEnvironment();
640     OH_VideoProcessing* videoProcessor = nullptr;
641     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
642         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
643     if (!access("/system/lib64/", 0)) {
644         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
645         ret = OH_VideoProcessing_Start(videoProcessor);
646         ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
647         OH_VideoProcessing_Destroy(videoProcessor);
648     } else {
649         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
650     }
651 }
652 
653 /**
654  * @tc.number    : VPE_VIDEO_API_TEST_0320
655  * @tc.name      : call OH_VideoProcessing_Start
656  * @tc.desc      : function test
657  */
658 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0320, TestSize.Level0)
659 {
660     OH_VideoProcessing_InitializeEnvironment();
661     OH_VideoProcessing* videoProcessor = nullptr;
662     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
663         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
664     if (!access("/system/lib64/", 0)) {
665         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
666         sptr<Surface> cs = Surface::CreateSurfaceAsConsumer();
667         sptr<IBufferConsumerListener> listener = new TestConsumerListener(
668             cs, "/data/test/media/out_320_240_10s.rgba");
669         cs->RegisterConsumerListener(listener);
670         auto p = cs->GetProducer();
671         sptr<Surface> ps = Surface::CreateSurfaceAsProducer(p);
672         OHNativeWindow *window = nullptr;
673         window = CreateNativeWindowFromSurface(&ps);
674         ret = OH_VideoProcessing_SetSurface(videoProcessor, window);
675         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
676         ret = OH_VideoProcessing_Start(videoProcessor);
677         ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
678         OH_VideoProcessing_Destroy(videoProcessor);
679         OH_NativeWindow_DestroyNativeWindow(window);
680     } else {
681         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
682     }
683 }
684 
685 /**
686  * @tc.number    : VPE_VIDEO_API_TEST_0330
687  * @tc.name      : call OH_VideoProcessing_Stop
688  * @tc.desc      : function test
689  */
690 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0330, TestSize.Level0)
691 {
692     OH_VideoProcessing_InitializeEnvironment();
693     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Stop(nullptr);
694     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
695 }
696 
697 /**
698  * @tc.number    : VPE_VIDEO_API_TEST_0340
699  * @tc.name      : call OH_VideoProcessing_Stop
700  * @tc.desc      : function test
701  */
702 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0340, TestSize.Level0)
703 {
704     OH_VideoProcessing_InitializeEnvironment();
705     OH_VideoProcessing* videoProcessor = nullptr;
706     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
707         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
708     if (!access("/system/lib64/", 0)) {
709         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
710         ret = OH_VideoProcessing_Stop(videoProcessor);
711         ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
712         OH_VideoProcessing_Destroy(videoProcessor);
713     } else {
714         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
715     }
716 }
717 
718 /**
719  * @tc.number    : VPE_VIDEO_API_TEST_0350
720  * @tc.name      : call OH_VideoProcessing_Stop
721  * @tc.desc      : function test
722  */
723 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0350, TestSize.Level0)
724 {
725     OH_VideoProcessing_InitializeEnvironment();
726     OH_VideoProcessing* videoProcessor = nullptr;
727     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
728         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
729     if (!access("/system/lib64/", 0)) {
730         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
731         sptr<Surface> cs = Surface::CreateSurfaceAsConsumer();
732         sptr<IBufferConsumerListener> listener = new TestConsumerListener(
733             cs, "/data/test/media/out_320_240_10s.rgba");
734         cs->RegisterConsumerListener(listener);
735         auto p = cs->GetProducer();
736         sptr<Surface> ps = Surface::CreateSurfaceAsProducer(p);
737         OHNativeWindow *window = nullptr;
738         window = CreateNativeWindowFromSurface(&ps);
739         ret = OH_VideoProcessing_SetSurface(videoProcessor, window);
740         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
741         OHNativeWindow *outwindow = nullptr;
742         ret = OH_VideoProcessing_GetSurface(videoProcessor, &outwindow);
743         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
744         ret = OH_VideoProcessing_Start(videoProcessor);
745         ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
746         ret = OH_VideoProcessing_Stop(videoProcessor);
747         ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
748         OH_VideoProcessing_Destroy(videoProcessor);
749         OH_NativeWindow_DestroyNativeWindow(window);
750     } else {
751         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
752     }
753 }
754 
755 /**
756  * @tc.number    : VPE_VIDEO_API_TEST_0360
757  * @tc.name      : call OH_VideoProcessing_RenderOutputBuffer
758  * @tc.desc      : function test
759  */
760 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0360, TestSize.Level0)
761 {
762     OH_VideoProcessing_InitializeEnvironment();
763     VideoProcessing_ErrorCode ret = OH_VideoProcessing_RenderOutputBuffer(nullptr, g_index);
764     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
765 }
766 
767 /**
768  * @tc.number    : VPE_VIDEO_API_TEST_0370
769  * @tc.name      : call OH_VideoProcessing_RenderOutputBuffer
770  * @tc.desc      : function test
771  */
772 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0370, TestSize.Level0)
773 {
774     OH_VideoProcessing_InitializeEnvironment();
775     OH_VideoProcessing* videoProcessor = nullptr;
776     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
777         VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
778     if (!access("/system/lib64/", 0)) {
779         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
780         ret = OH_VideoProcessing_RenderOutputBuffer(videoProcessor, INT_MAX);
781         ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
782         OH_VideoProcessing_Destroy(videoProcessor);
783     } else {
784         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
785     }
786 }
787 
788 /**
789  * @tc.number    : VPE_VIDEO_API_TEST_0380
790  * @tc.name      : call OH_VideoProcessingCallback_Create
791  * @tc.desc      : function test
792  */
793 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0380, TestSize.Level0)
794 {
795     OH_VideoProcessing_InitializeEnvironment();
796     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(nullptr);
797     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
798 }
799 
800 /**
801  * @tc.number    : VPE_VIDEO_API_TEST_0390
802  * @tc.name      : call OH_VideoProcessingCallback_Create
803  * @tc.desc      : function test
804  */
805 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0390, TestSize.Level0)
806 {
807     OH_VideoProcessing_InitializeEnvironment();
808     VideoProcessing_Callback* callback = nullptr;
809     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
810     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
811     OH_VideoProcessingCallback_Destroy(callback);
812 }
813 
814 /**
815  * @tc.number    : VPE_VIDEO_API_TEST_0400
816  * @tc.name      : call OH_VideoProcessingCallback_Destroy
817  * @tc.desc      : function test
818  */
819 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0400, TestSize.Level0)
820 {
821     OH_VideoProcessing_InitializeEnvironment();
822     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Destroy(nullptr);
823     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
824 }
825 
826 /**
827  * @tc.number    : VPE_VIDEO_API_TEST_0410
828  * @tc.name      : call OH_VideoProcessingCallback_Destroy
829  * @tc.desc      : function test
830  */
831 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0410, TestSize.Level0)
832 {
833     OH_VideoProcessing_InitializeEnvironment();
834     VideoProcessing_Callback* callback = nullptr;
835     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
836     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
837     ret = OH_VideoProcessingCallback_Destroy(callback);
838     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
839 }
840 
841 /**
842  * @tc.number    : VPE_VIDEO_API_TEST_0420
843  * @tc.name      : call OH_VideoProcessingCallback_BindOnError
844  * @tc.desc      : function test
845  */
846 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0420, TestSize.Level0)
847 {
848     OH_VideoProcessing_InitializeEnvironment();
849     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_BindOnError(
850         nullptr, onErrorEmptyCallback);
851     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
852 }
853 
854 /**
855  * @tc.number    : VPE_VIDEO_API_TEST_0430
856  * @tc.name      : call OH_VideoProcessingCallback_BindOnError
857  * @tc.desc      : function test
858  */
859 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0430, TestSize.Level0)
860 {
861     OH_VideoProcessing_InitializeEnvironment();
862     VideoProcessing_Callback* callback = nullptr;
863     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
864     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
865     ret = OH_VideoProcessingCallback_BindOnError(
866         callback, onErrorEmptyCallback);
867     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
868     OH_VideoProcessingCallback_Destroy(callback);
869 }
870 
871 /**
872  * @tc.number    : VPE_VIDEO_API_TEST_0440
873  * @tc.name      : call OH_VideoProcessingCallback_BindOnError
874  * @tc.desc      : function test
875  */
876 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0440, TestSize.Level0)
877 {
878     OH_VideoProcessing_InitializeEnvironment();
879     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_BindOnError(
880         nullptr, onErrorCallback);
881     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
882 }
883 
884 /**
885  * @tc.number    : VPE_VIDEO_API_TEST_0450
886  * @tc.name      : call OH_VideoProcessingCallback_BindOnError
887  * @tc.desc      : function test
888  */
889 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0450, TestSize.Level0)
890 {
891     OH_VideoProcessing_InitializeEnvironment();
892     VideoProcessing_Callback* callback = nullptr;
893     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
894     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
895     ret = OH_VideoProcessingCallback_BindOnError(callback, onErrorCallback);
896     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
897     OH_VideoProcessingCallback_Destroy(callback);
898 }
899 
900 /**
901  * @tc.number    : VPE_VIDEO_API_TEST_0460
902  * @tc.name      : call OH_VideoProcessingCallback_BindOnState
903  * @tc.desc      : function test
904  */
905 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0460, TestSize.Level0)
906 {
907     OH_VideoProcessing_InitializeEnvironment();
908     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_BindOnState(
909         nullptr, onStateEmptyCallback);
910     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
911 }
912 
913 /**
914  * @tc.number    : VPE_VIDEO_API_TEST_0470
915  * @tc.name      : call OH_VideoProcessingCallback_BindOnState
916  * @tc.desc      : function test
917  */
918 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0470, TestSize.Level0)
919 {
920     OH_VideoProcessing_InitializeEnvironment();
921     VideoProcessing_Callback* callback = nullptr;
922     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
923     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
924     ret = OH_VideoProcessingCallback_BindOnState(callback, onStateEmptyCallback);
925     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
926     OH_VideoProcessingCallback_Destroy(callback);
927 }
928 
929 /**
930  * @tc.number    : VPE_VIDEO_API_TEST_0480
931  * @tc.name      : call OH_VideoProcessingCallback_BindOnState
932  * @tc.desc      : function test
933  */
934 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0480, TestSize.Level0)
935 {
936     OH_VideoProcessing_InitializeEnvironment();
937     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_BindOnState(nullptr, onStateCallback);
938     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
939 }
940 
941 /**
942  * @tc.number    : VPE_VIDEO_API_TEST_0490
943  * @tc.name      : call OH_VideoProcessingCallback_BindOnState
944  * @tc.desc      : function test
945  */
946 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0490, TestSize.Level0)
947 {
948     OH_VideoProcessing_InitializeEnvironment();
949     VideoProcessing_Callback* callback = nullptr;
950     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
951     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
952     ret = OH_VideoProcessingCallback_BindOnState(callback, onStateCallback);
953     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
954     OH_VideoProcessingCallback_Destroy(callback);
955 }
956 
957 /**
958  * @tc.number    : VPE_VIDEO_API_TEST_0500
959  * @tc.name      : call OH_VideoProcessingCallback_BindOnNewOutputBuffer
960  * @tc.desc      : function test
961  */
962 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0500, TestSize.Level0)
963 {
964     OH_VideoProcessing_InitializeEnvironment();
965     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(
966         nullptr, OnNewOutputBufferEmptyCallback);
967     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
968 }
969 
970 /**
971  * @tc.number    : VPE_VIDEO_API_TEST_0510
972  * @tc.name      : call OH_VideoProcessingCallback_BindOnNewOutputBuffer
973  * @tc.desc      : function test
974  */
975 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0510, TestSize.Level0)
976 {
977     OH_VideoProcessing_InitializeEnvironment();
978     VideoProcessing_Callback* callback = nullptr;
979     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
980     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
981     ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBufferEmptyCallback);
982     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
983     OH_VideoProcessingCallback_Destroy(callback);
984 }
985 
986 /**
987  * @tc.number    : VPE_VIDEO_API_TEST_0520
988  * @tc.name      : call OH_VideoProcessingCallback_BindOnNewOutputBuffer
989  * @tc.desc      : function test
990  */
991 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0520, TestSize.Level0)
992 {
993     OH_VideoProcessing_InitializeEnvironment();
994     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(
995         nullptr, OnNewOutputBufferCallback);
996     ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
997 }
998 
999 /**
1000  * @tc.number    : VPE_VIDEO_API_TEST_0530
1001  * @tc.name      : call OH_VideoProcessingCallback_BindOnNewOutputBuffer
1002  * @tc.desc      : function test
1003  */
1004 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0530, TestSize.Level0)
1005 {
1006     OH_VideoProcessing_InitializeEnvironment();
1007     VideoProcessing_Callback* callback = nullptr;
1008     VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
1009     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1010     ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBufferCallback);
1011     ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1012     OH_VideoProcessingCallback_Destroy(callback);
1013 }
1014 
1015 /**
1016  * @tc.number    : VPE_VIDEO_API_TEST_05400
1017  * @tc.name      : call OH_VideoProcessing_Create
1018  * @tc.desc      : function test
1019  */
1020 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0540, TestSize.Level0)
1021 {
1022     OH_VideoProcessing_InitializeEnvironment();
1023     OH_VideoProcessing* videoProcessor = nullptr;
1024     VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
1025         VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION);
1026     if (!access("/system/lib64/", 0)) {
1027         ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1028         OH_VideoProcessing_Destroy(videoProcessor);
1029     } else {
1030         ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
1031     }
1032 }
1033 }