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 #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 #ifdef ENABLE_ALL_PROCESS
115 static bool g_suppported = true;
116 #else
117 static bool g_suppported = false;
118 #endif
119
120 /**
121 * @tc.number : VPE_VIDEO_API_TEST_0010
122 * @tc.name : first call OH_VideoProcessing_InitializeEnvironment
123 * @tc.desc : function test
124 */
125 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0010, TestSize.Level0)
126 {
127 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
128 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
129 OH_VideoProcessing_DeinitializeEnvironment();
130 }
131
132 /**
133 * @tc.number : VPE_VIDEO_API_TEST_0020
134 * @tc.name : first call OH_VideoProcessing_DeinitializeEnvironment
135 * @tc.desc : function test
136 */
137 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0020, TestSize.Level0)
138 {
139 VideoProcessing_ErrorCode ret = OH_VideoProcessing_DeinitializeEnvironment();
140 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
141 }
142
143 /**
144 * @tc.number : VPE_VIDEO_API_TEST_0030
145 * @tc.name : call OH_VideoProcessing_DeinitializeEnvironment after initialize
146 * @tc.desc : function test
147 */
148 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0030, TestSize.Level0)
149 {
150 VideoProcessing_ErrorCode ret = OH_VideoProcessing_InitializeEnvironment();
151 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
152 ret = OH_VideoProcessing_DeinitializeEnvironment();
153 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
154 }
155
156 /**
157 * @tc.number : VPE_VIDEO_API_TEST_0040
158 * @tc.name : call OH_VideoProcessing_IsColorSpaceConversionSupported with nullptr,nullptr
159 * @tc.desc : function test
160 */
161 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0040, TestSize.Level0)
162 {
163 OH_VideoProcessing_InitializeEnvironment();
164 bool ret = OH_VideoProcessing_IsColorSpaceConversionSupported(nullptr, nullptr);
165 ASSERT_FALSE(ret);
166 OH_VideoProcessing_DeinitializeEnvironment();
167 }
168
169 /**
170 * @tc.number : VPE_VIDEO_API_TEST_0050
171 * @tc.name : call OH_VideoProcessing_IsColorSpaceConversionSupported
172 * @tc.desc : function test
173 */
174 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0050, TestSize.Level0)
175 {
176 OH_VideoProcessing_InitializeEnvironment();
177 bool ret = OH_VideoProcessing_IsColorSpaceConversionSupported(&SRC_INFO, nullptr);
178 ASSERT_FALSE(ret);
179 }
180
181 /**
182 * @tc.number : VPE_VIDEO_API_TEST_0060
183 * @tc.name : call OH_VideoProcessing_IsColorSpaceConversionSupported
184 * @tc.desc : function test
185 */
186 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0060, TestSize.Level0)
187 {
188 OH_VideoProcessing_InitializeEnvironment();
189 bool ret = OH_VideoProcessing_IsColorSpaceConversionSupported(nullptr, &DST_INFO);
190 ASSERT_FALSE(ret);
191 }
192
193 /**
194 * @tc.number : VPE_VIDEO_API_TEST_0070
195 * @tc.name : call OH_VideoProcessing_IsColorSpaceConversionSupported
196 * @tc.desc : function test
197 */
198 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0070, TestSize.Level0)
199 {
200 OH_VideoProcessing_InitializeEnvironment();
201 bool ret = OH_VideoProcessing_IsColorSpaceConversionSupported(&SRC_INFO, &DST_INFO);
202 if (g_suppported) {
203 ASSERT_TRUE(ret);
204 } else {
205 ASSERT_FALSE(ret);
206 }
207 }
208
209 /**
210 * @tc.number : VPE_VIDEO_API_TEST_0080
211 * @tc.name : call OH_VideoProcessing_IsMetadataGenerationSupported
212 * @tc.desc : function test
213 */
214 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0080, TestSize.Level0)
215 {
216 OH_VideoProcessing_InitializeEnvironment();
217 bool ret = OH_VideoProcessing_IsMetadataGenerationSupported(nullptr);
218 ASSERT_FALSE(ret);
219 }
220
221 /**
222 * @tc.number : VPE_VIDEO_API_TEST_0090
223 * @tc.name : call OH_VideoProcessing_IsMetadataGenerationSupported
224 * @tc.desc : function test
225 */
226 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0090, TestSize.Level0)
227 {
228 OH_VideoProcessing_InitializeEnvironment();
229 bool ret = OH_VideoProcessing_IsMetadataGenerationSupported(&SRC_INFO);
230 if (g_suppported) {
231 ASSERT_TRUE(ret);
232 } else {
233 ASSERT_FALSE(ret);
234 }
235 }
236
237 /**
238 * @tc.number : VPE_VIDEO_API_TEST_0100
239 * @tc.name : call OH_VideoProcessing_Create
240 * @tc.desc : function test
241 */
242 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0100, TestSize.Level0)
243 {
244 OH_VideoProcessing_InitializeEnvironment();
245 OH_VideoProcessing** videoProcessor = nullptr;
246 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(videoProcessor, INT_MAX);
247 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
248 }
249
250 /**
251 * @tc.number : VPE_VIDEO_API_TEST_0110
252 * @tc.name : call OH_VideoProcessing_Create
253 * @tc.desc : function test
254 */
255 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0110, TestSize.Level0)
256 {
257 OH_VideoProcessing_InitializeEnvironment();
258 OH_VideoProcessing** videoProcessor = nullptr;
259 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(videoProcessor,
260 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
261 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
262 }
263
264 /**
265 * @tc.number : VPE_VIDEO_API_TEST_0120
266 * @tc.name : call OH_VideoProcessing_Create
267 * @tc.desc : function test
268 */
269 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0120, TestSize.Level0)
270 {
271 OH_VideoProcessing_InitializeEnvironment();
272 OH_VideoProcessing* videoProcessor = nullptr;
273 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor, INT_MAX);
274 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
275 OH_VideoProcessing_Destroy(videoProcessor);
276 }
277
278 /**
279 * @tc.number : VPE_VIDEO_API_TEST_0130
280 * @tc.name : call OH_VideoProcessing_Create
281 * @tc.desc : function test
282 */
283 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0130, TestSize.Level0)
284 {
285 OH_VideoProcessing_InitializeEnvironment();
286 OH_VideoProcessing* videoProcessor = nullptr;
287 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
288 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
289 if (g_suppported) {
290 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
291 OH_VideoProcessing_Destroy(videoProcessor);
292 } else {
293 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
294 }
295 }
296
297 /**
298 * @tc.number : VPE_VIDEO_API_TEST_0140
299 * @tc.name : call OH_VideoProcessing_Destroy
300 * @tc.desc : function test
301 */
302 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0140, TestSize.Level0)
303 {
304 OH_VideoProcessing_InitializeEnvironment();
305 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Destroy(nullptr);
306 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
307 }
308
309 /**
310 * @tc.number : VPE_VIDEO_API_TEST_0150
311 * @tc.name : call OH_VideoProcessing_Destroy
312 * @tc.desc : function test
313 */
314 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0150, TestSize.Level0)
315 {
316 OH_VideoProcessing_InitializeEnvironment();
317 OH_VideoProcessing* videoProcessor = nullptr;
318 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
319 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
320 if (g_suppported) {
321 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
322 ret = OH_VideoProcessing_Destroy(videoProcessor);
323 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
324 } else {
325 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
326 }
327 }
328
329 /**
330 * @tc.number : VPE_VIDEO_API_TEST_0160
331 * @tc.name : call OH_VideoProcessing_RegisterCallback
332 * @tc.desc : function test
333 */
334 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0160, TestSize.Level0)
335 {
336 OH_VideoProcessing_InitializeEnvironment();
337 VideoProcessing_ErrorCode ret = OH_VideoProcessing_RegisterCallback(nullptr, nullptr, nullptr);
338 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
339 }
340
341 /**
342 * @tc.number : VPE_VIDEO_API_TEST_0170
343 * @tc.name : call OH_VideoProcessing_RegisterCallback
344 * @tc.desc : function test
345 */
346 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0170, TestSize.Level0)
347 {
348 OH_VideoProcessing_InitializeEnvironment();
349 VideoProcessing_Callback* callback = nullptr;
350 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
351 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
352 ret = OH_VideoProcessing_RegisterCallback(nullptr, callback, nullptr);
353 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
354 OH_VideoProcessingCallback_Destroy(callback);
355 }
356
357 /**
358 * @tc.number : VPE_VIDEO_API_TEST_0180
359 * @tc.name : call OH_VideoProcessing_RegisterCallback
360 * @tc.desc : function test
361 */
362 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0180, TestSize.Level0)
363 {
364 OH_VideoProcessing_InitializeEnvironment();
365 OH_VideoProcessing* videoProcessor = nullptr;
366 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
367 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
368 if (g_suppported) {
369 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
370 ret = OH_VideoProcessing_RegisterCallback(videoProcessor, nullptr, nullptr);
371 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
372 OH_VideoProcessing_Destroy(videoProcessor);
373 } else {
374 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
375 }
376 }
377
378 /**
379 * @tc.number : VPE_VIDEO_API_TEST_0190
380 * @tc.name : call OH_VideoProcessing_RegisterCallback
381 * @tc.desc : function test
382 */
383 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0190, TestSize.Level0)
384 {
385 OH_VideoProcessing_InitializeEnvironment();
386 OH_VideoProcessing* videoProcessor = nullptr;
387 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
388 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
389 if (g_suppported) {
390 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
391 VideoProcessing_Callback* callback = nullptr;
392 ret = OH_VideoProcessingCallback_Create(&callback);
393 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
394 ret = OH_VideoProcessingCallback_BindOnError(callback, onErrorEmptyCallback);
395 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
396 ret = OH_VideoProcessing_RegisterCallback(videoProcessor, callback, nullptr);
397 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
398 OH_VideoProcessing_Destroy(videoProcessor);
399 OH_VideoProcessingCallback_Destroy(callback);
400 } else {
401 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
402 }
403 }
404
405 /**
406 * @tc.number : VPE_VIDEO_API_TEST_0200
407 * @tc.name : call OH_VideoProcessing_RegisterCallback
408 * @tc.desc : function test
409 */
410 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0200, TestSize.Level0)
411 {
412 OH_VideoProcessing_InitializeEnvironment();
413 OH_VideoProcessing* videoProcessor = nullptr;
414 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
415 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
416 if (g_suppported) {
417 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
418 VideoProcessing_Callback* callback = nullptr;
419 ret = OH_VideoProcessingCallback_Create(&callback);
420 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
421 ret = OH_VideoProcessing_RegisterCallback(videoProcessor, callback, nullptr);
422 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_VALUE);
423 OH_VideoProcessing_Destroy(videoProcessor);
424 OH_VideoProcessingCallback_Destroy(callback);
425 } else {
426 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
427 }
428 }
429
430 /**
431 * @tc.number : VPE_VIDEO_API_TEST_0210
432 * @tc.name : call OH_VideoProcessing_RegisterCallback
433 * @tc.desc : function test
434 */
435 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0210, TestSize.Level0)
436 {
437 OH_VideoProcessing_InitializeEnvironment();
438 OH_VideoProcessing* videoProcessor = nullptr;
439 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
440 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
441 if (g_suppported) {
442 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
443 VideoProcessing_Callback* callback = nullptr;
444 ret = OH_VideoProcessingCallback_Create(&callback);
445 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
446 void* userData = &g_userValue;
447 if (!userData) {
448 ret = OH_VideoProcessing_RegisterCallback(videoProcessor, callback, userData);
449 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
450 }
451 OH_VideoProcessing_Destroy(videoProcessor);
452 OH_VideoProcessingCallback_Destroy(callback);
453 } else {
454 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
455 }
456 }
457
458 /**
459 * @tc.number : VPE_VIDEO_API_TEST_0220
460 * @tc.name : call OH_VideoProcessing_SetSurface
461 * @tc.desc : function test
462 */
463 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0220, TestSize.Level0)
464 {
465 OH_VideoProcessing_InitializeEnvironment();
466 VideoProcessing_ErrorCode ret = OH_VideoProcessing_SetSurface(nullptr, nullptr);
467 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
468 }
469
470 /**
471 * @tc.number : VPE_VIDEO_API_TEST_0230
472 * @tc.name : call OH_VideoProcessing_SetSurface
473 * @tc.desc : function test
474 */
475 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0230, TestSize.Level0)
476 {
477 OH_VideoProcessing_InitializeEnvironment();
478 sptr<Surface> cs = Surface::CreateSurfaceAsConsumer();
479 sptr<IBufferConsumerListener> listener = new TestConsumerListener(
480 cs, "/data/test/media/out_320_240_10s.rgba");
481 cs->RegisterConsumerListener(listener);
482 auto p = cs->GetProducer();
483 sptr<Surface> ps = Surface::CreateSurfaceAsProducer(p);
484 OHNativeWindow *window = nullptr;
485 window = CreateNativeWindowFromSurface(&ps);
486 VideoProcessing_ErrorCode ret = OH_VideoProcessing_SetSurface(nullptr, window);
487 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
488 OH_NativeWindow_DestroyNativeWindow(window);
489 }
490
491 /**
492 * @tc.number : VPE_VIDEO_API_TEST_0240
493 * @tc.name : call OH_VideoProcessing_SetSurface
494 * @tc.desc : function test
495 */
496 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0240, TestSize.Level0)
497 {
498 OH_VideoProcessing_InitializeEnvironment();
499 OH_VideoProcessing* videoProcessor = nullptr;
500 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
501 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
502 if (g_suppported) {
503 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
504 ret = OH_VideoProcessing_SetSurface(videoProcessor, nullptr);
505 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
506 OH_VideoProcessing_Destroy(videoProcessor);
507 } else {
508 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
509 }
510 }
511
512 /**
513 * @tc.number : VPE_VIDEO_API_TEST_0250
514 * @tc.name : call OH_VideoProcessing_SetSurface
515 * @tc.desc : function test
516 */
517 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0250, TestSize.Level0)
518 {
519 OH_VideoProcessing_InitializeEnvironment();
520 OH_VideoProcessing* videoProcessor = nullptr;
521 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
522 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
523 if (g_suppported) {
524 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
525 sptr<Surface> cs = Surface::CreateSurfaceAsConsumer();
526 sptr<IBufferConsumerListener> listener = new TestConsumerListener(
527 cs, "/data/test/media/out_320_240_10s.rgba");
528 cs->RegisterConsumerListener(listener);
529 auto p = cs->GetProducer();
530 sptr<Surface> ps = Surface::CreateSurfaceAsProducer(p);
531 OHNativeWindow *window = nullptr;
532 window = CreateNativeWindowFromSurface(&ps);
533 ret = OH_VideoProcessing_SetSurface(videoProcessor, window);
534 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
535 OH_VideoProcessing_Destroy(videoProcessor);
536 OH_NativeWindow_DestroyNativeWindow(window);
537 } else {
538 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
539 }
540 }
541
542 /**
543 * @tc.number : VPE_VIDEO_API_TEST_0260
544 * @tc.name : call OH_VideoProcessing_GetSurface
545 * @tc.desc : function test
546 */
547 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0260, TestSize.Level0)
548 {
549 OH_VideoProcessing_InitializeEnvironment();
550 VideoProcessing_ErrorCode ret = OH_VideoProcessing_GetSurface(nullptr, nullptr);
551 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
552 }
553
554 /**
555 * @tc.number : VPE_VIDEO_API_TEST_0270
556 * @tc.name : call OH_VideoProcessing_GetSurface
557 * @tc.desc : function test
558 */
559 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0270, TestSize.Level0)
560 {
561 OH_VideoProcessing_InitializeEnvironment();
562 sptr<Surface> cs = Surface::CreateSurfaceAsConsumer();
563 sptr<IBufferConsumerListener> listener = new TestConsumerListener(
564 cs, "/data/test/media/out_320_240_10s.rgba");
565 cs->RegisterConsumerListener(listener);
566 auto p = cs->GetProducer();
567 sptr<Surface> ps = Surface::CreateSurfaceAsProducer(p);
568 OHNativeWindow *window = nullptr;
569 window = CreateNativeWindowFromSurface(&ps);
570 VideoProcessing_ErrorCode ret = OH_VideoProcessing_GetSurface(nullptr, &window);
571 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
572 OH_NativeWindow_DestroyNativeWindow(window);
573 }
574
575 /**
576 * @tc.number : VPE_VIDEO_API_TEST_0280
577 * @tc.name : call OH_VideoProcessing_GetSurface
578 * @tc.desc : function test
579 */
580 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0280, TestSize.Level0)
581 {
582 OH_VideoProcessing_InitializeEnvironment();
583 OH_VideoProcessing* videoProcessor = nullptr;
584 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
585 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
586 if (g_suppported) {
587 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
588 ret = OH_VideoProcessing_GetSurface(videoProcessor, nullptr);
589 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
590 OH_VideoProcessing_Destroy(videoProcessor);
591 } else {
592 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
593 }
594 }
595
596 /**
597 * @tc.number : VPE_VIDEO_API_TEST_0290
598 * @tc.name : call OH_VideoProcessing_GetSurface
599 * @tc.desc : function test
600 */
601 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0290, TestSize.Level0)
602 {
603 OH_VideoProcessing_InitializeEnvironment();
604 OH_VideoProcessing* videoProcessor = nullptr;
605 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
606 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
607 if (g_suppported) {
608 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
609 sptr<Surface> cs = Surface::CreateSurfaceAsConsumer();
610 sptr<IBufferConsumerListener> listener = new TestConsumerListener(
611 cs, "/data/test/media/out_320_240_10s.rgba");
612 cs->RegisterConsumerListener(listener);
613 auto p = cs->GetProducer();
614 sptr<Surface> ps = Surface::CreateSurfaceAsProducer(p);
615 OHNativeWindow *window = nullptr;
616 window = CreateNativeWindowFromSurface(&ps);
617 ret = OH_VideoProcessing_GetSurface(videoProcessor, &window);
618 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
619 OH_VideoProcessing_Destroy(videoProcessor);
620 OH_NativeWindow_DestroyNativeWindow(window);
621 } else {
622 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
623 }
624 }
625
626 /**
627 * @tc.number : VPE_VIDEO_API_TEST_0300
628 * @tc.name : call OH_VideoProcessing_Start
629 * @tc.desc : function test
630 */
631 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0300, TestSize.Level0)
632 {
633 OH_VideoProcessing_InitializeEnvironment();
634 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Start(nullptr);
635 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
636 }
637
638 /**
639 * @tc.number : VPE_VIDEO_API_TEST_0310
640 * @tc.name : call OH_VideoProcessing_Start
641 * @tc.desc : function test
642 */
643 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0310, TestSize.Level0)
644 {
645 OH_VideoProcessing_InitializeEnvironment();
646 OH_VideoProcessing* videoProcessor = nullptr;
647 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
648 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
649 if (g_suppported) {
650 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
651 ret = OH_VideoProcessing_Start(videoProcessor);
652 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
653 OH_VideoProcessing_Destroy(videoProcessor);
654 } else {
655 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
656 }
657 }
658
659 /**
660 * @tc.number : VPE_VIDEO_API_TEST_0320
661 * @tc.name : call OH_VideoProcessing_Start
662 * @tc.desc : function test
663 */
664 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0320, TestSize.Level0)
665 {
666 OH_VideoProcessing_InitializeEnvironment();
667 OH_VideoProcessing* videoProcessor = nullptr;
668 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
669 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
670 if (g_suppported) {
671 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
672 sptr<Surface> cs = Surface::CreateSurfaceAsConsumer();
673 sptr<IBufferConsumerListener> listener = new TestConsumerListener(
674 cs, "/data/test/media/out_320_240_10s.rgba");
675 cs->RegisterConsumerListener(listener);
676 auto p = cs->GetProducer();
677 sptr<Surface> ps = Surface::CreateSurfaceAsProducer(p);
678 OHNativeWindow *window = nullptr;
679 window = CreateNativeWindowFromSurface(&ps);
680 ret = OH_VideoProcessing_SetSurface(videoProcessor, window);
681 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
682 ret = OH_VideoProcessing_Start(videoProcessor);
683 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
684 OH_VideoProcessing_Destroy(videoProcessor);
685 OH_NativeWindow_DestroyNativeWindow(window);
686 } else {
687 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
688 }
689 }
690
691 /**
692 * @tc.number : VPE_VIDEO_API_TEST_0330
693 * @tc.name : call OH_VideoProcessing_Stop
694 * @tc.desc : function test
695 */
696 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0330, TestSize.Level0)
697 {
698 OH_VideoProcessing_InitializeEnvironment();
699 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Stop(nullptr);
700 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
701 }
702
703 /**
704 * @tc.number : VPE_VIDEO_API_TEST_0340
705 * @tc.name : call OH_VideoProcessing_Stop
706 * @tc.desc : function test
707 */
708 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0340, TestSize.Level0)
709 {
710 OH_VideoProcessing_InitializeEnvironment();
711 OH_VideoProcessing* videoProcessor = nullptr;
712 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
713 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
714 if (g_suppported) {
715 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
716 ret = OH_VideoProcessing_Stop(videoProcessor);
717 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
718 OH_VideoProcessing_Destroy(videoProcessor);
719 } else {
720 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
721 }
722 }
723
724 /**
725 * @tc.number : VPE_VIDEO_API_TEST_0350
726 * @tc.name : call OH_VideoProcessing_Stop
727 * @tc.desc : function test
728 */
729 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0350, TestSize.Level0)
730 {
731 OH_VideoProcessing_InitializeEnvironment();
732 OH_VideoProcessing* videoProcessor = nullptr;
733 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
734 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
735 if (g_suppported) {
736 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
737 sptr<Surface> cs = Surface::CreateSurfaceAsConsumer();
738 sptr<IBufferConsumerListener> listener = new TestConsumerListener(
739 cs, "/data/test/media/out_320_240_10s.rgba");
740 cs->RegisterConsumerListener(listener);
741 auto p = cs->GetProducer();
742 sptr<Surface> ps = Surface::CreateSurfaceAsProducer(p);
743 OHNativeWindow *window = nullptr;
744 window = CreateNativeWindowFromSurface(&ps);
745 ret = OH_VideoProcessing_SetSurface(videoProcessor, window);
746 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
747 OHNativeWindow *outwindow = nullptr;
748 ret = OH_VideoProcessing_GetSurface(videoProcessor, &outwindow);
749 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
750 ret = OH_VideoProcessing_Start(videoProcessor);
751 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
752 ret = OH_VideoProcessing_Stop(videoProcessor);
753 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
754 OH_VideoProcessing_Destroy(videoProcessor);
755 OH_NativeWindow_DestroyNativeWindow(window);
756 } else {
757 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
758 }
759 }
760
761 /**
762 * @tc.number : VPE_VIDEO_API_TEST_0360
763 * @tc.name : call OH_VideoProcessing_RenderOutputBuffer
764 * @tc.desc : function test
765 */
766 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0360, TestSize.Level0)
767 {
768 OH_VideoProcessing_InitializeEnvironment();
769 VideoProcessing_ErrorCode ret = OH_VideoProcessing_RenderOutputBuffer(nullptr, g_index);
770 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_INSTANCE);
771 }
772
773 /**
774 * @tc.number : VPE_VIDEO_API_TEST_0370
775 * @tc.name : call OH_VideoProcessing_RenderOutputBuffer
776 * @tc.desc : function test
777 */
778 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0370, TestSize.Level0)
779 {
780 OH_VideoProcessing_InitializeEnvironment();
781 OH_VideoProcessing* videoProcessor = nullptr;
782 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
783 VIDEO_PROCESSING_TYPE_METADATA_GENERATION);
784 if (g_suppported) {
785 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
786 ret = OH_VideoProcessing_RenderOutputBuffer(videoProcessor, INT_MAX);
787 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_OPERATION_NOT_PERMITTED);
788 OH_VideoProcessing_Destroy(videoProcessor);
789 } else {
790 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
791 }
792 }
793
794 /**
795 * @tc.number : VPE_VIDEO_API_TEST_0380
796 * @tc.name : call OH_VideoProcessingCallback_Create
797 * @tc.desc : function test
798 */
799 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0380, TestSize.Level0)
800 {
801 OH_VideoProcessing_InitializeEnvironment();
802 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(nullptr);
803 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
804 }
805
806 /**
807 * @tc.number : VPE_VIDEO_API_TEST_0390
808 * @tc.name : call OH_VideoProcessingCallback_Create
809 * @tc.desc : function test
810 */
811 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0390, TestSize.Level0)
812 {
813 OH_VideoProcessing_InitializeEnvironment();
814 VideoProcessing_Callback* callback = nullptr;
815 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
816 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
817 OH_VideoProcessingCallback_Destroy(callback);
818 }
819
820 /**
821 * @tc.number : VPE_VIDEO_API_TEST_0400
822 * @tc.name : call OH_VideoProcessingCallback_Destroy
823 * @tc.desc : function test
824 */
825 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0400, TestSize.Level0)
826 {
827 OH_VideoProcessing_InitializeEnvironment();
828 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Destroy(nullptr);
829 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
830 }
831
832 /**
833 * @tc.number : VPE_VIDEO_API_TEST_0410
834 * @tc.name : call OH_VideoProcessingCallback_Destroy
835 * @tc.desc : function test
836 */
837 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0410, TestSize.Level0)
838 {
839 OH_VideoProcessing_InitializeEnvironment();
840 VideoProcessing_Callback* callback = nullptr;
841 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
842 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
843 ret = OH_VideoProcessingCallback_Destroy(callback);
844 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
845 }
846
847 /**
848 * @tc.number : VPE_VIDEO_API_TEST_0420
849 * @tc.name : call OH_VideoProcessingCallback_BindOnError
850 * @tc.desc : function test
851 */
852 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0420, TestSize.Level0)
853 {
854 OH_VideoProcessing_InitializeEnvironment();
855 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_BindOnError(
856 nullptr, onErrorEmptyCallback);
857 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
858 }
859
860 /**
861 * @tc.number : VPE_VIDEO_API_TEST_0430
862 * @tc.name : call OH_VideoProcessingCallback_BindOnError
863 * @tc.desc : function test
864 */
865 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0430, TestSize.Level0)
866 {
867 OH_VideoProcessing_InitializeEnvironment();
868 VideoProcessing_Callback* callback = nullptr;
869 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
870 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
871 ret = OH_VideoProcessingCallback_BindOnError(
872 callback, onErrorEmptyCallback);
873 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
874 OH_VideoProcessingCallback_Destroy(callback);
875 }
876
877 /**
878 * @tc.number : VPE_VIDEO_API_TEST_0440
879 * @tc.name : call OH_VideoProcessingCallback_BindOnError
880 * @tc.desc : function test
881 */
882 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0440, TestSize.Level0)
883 {
884 OH_VideoProcessing_InitializeEnvironment();
885 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_BindOnError(
886 nullptr, onErrorCallback);
887 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
888 }
889
890 /**
891 * @tc.number : VPE_VIDEO_API_TEST_0450
892 * @tc.name : call OH_VideoProcessingCallback_BindOnError
893 * @tc.desc : function test
894 */
895 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0450, TestSize.Level0)
896 {
897 OH_VideoProcessing_InitializeEnvironment();
898 VideoProcessing_Callback* callback = nullptr;
899 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
900 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
901 ret = OH_VideoProcessingCallback_BindOnError(callback, onErrorCallback);
902 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
903 OH_VideoProcessingCallback_Destroy(callback);
904 }
905
906 /**
907 * @tc.number : VPE_VIDEO_API_TEST_0460
908 * @tc.name : call OH_VideoProcessingCallback_BindOnState
909 * @tc.desc : function test
910 */
911 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0460, TestSize.Level0)
912 {
913 OH_VideoProcessing_InitializeEnvironment();
914 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_BindOnState(
915 nullptr, onStateEmptyCallback);
916 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
917 }
918
919 /**
920 * @tc.number : VPE_VIDEO_API_TEST_0470
921 * @tc.name : call OH_VideoProcessingCallback_BindOnState
922 * @tc.desc : function test
923 */
924 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0470, TestSize.Level0)
925 {
926 OH_VideoProcessing_InitializeEnvironment();
927 VideoProcessing_Callback* callback = nullptr;
928 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
929 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
930 ret = OH_VideoProcessingCallback_BindOnState(callback, onStateEmptyCallback);
931 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
932 OH_VideoProcessingCallback_Destroy(callback);
933 }
934
935 /**
936 * @tc.number : VPE_VIDEO_API_TEST_0480
937 * @tc.name : call OH_VideoProcessingCallback_BindOnState
938 * @tc.desc : function test
939 */
940 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0480, TestSize.Level0)
941 {
942 OH_VideoProcessing_InitializeEnvironment();
943 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_BindOnState(nullptr, onStateCallback);
944 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
945 }
946
947 /**
948 * @tc.number : VPE_VIDEO_API_TEST_0490
949 * @tc.name : call OH_VideoProcessingCallback_BindOnState
950 * @tc.desc : function test
951 */
952 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0490, TestSize.Level0)
953 {
954 OH_VideoProcessing_InitializeEnvironment();
955 VideoProcessing_Callback* callback = nullptr;
956 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
957 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
958 ret = OH_VideoProcessingCallback_BindOnState(callback, onStateCallback);
959 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
960 OH_VideoProcessingCallback_Destroy(callback);
961 }
962
963 /**
964 * @tc.number : VPE_VIDEO_API_TEST_0500
965 * @tc.name : call OH_VideoProcessingCallback_BindOnNewOutputBuffer
966 * @tc.desc : function test
967 */
968 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0500, TestSize.Level0)
969 {
970 OH_VideoProcessing_InitializeEnvironment();
971 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(
972 nullptr, OnNewOutputBufferEmptyCallback);
973 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
974 }
975
976 /**
977 * @tc.number : VPE_VIDEO_API_TEST_0510
978 * @tc.name : call OH_VideoProcessingCallback_BindOnNewOutputBuffer
979 * @tc.desc : function test
980 */
981 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0510, TestSize.Level0)
982 {
983 OH_VideoProcessing_InitializeEnvironment();
984 VideoProcessing_Callback* callback = nullptr;
985 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
986 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
987 ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBufferEmptyCallback);
988 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
989 OH_VideoProcessingCallback_Destroy(callback);
990 }
991
992 /**
993 * @tc.number : VPE_VIDEO_API_TEST_0520
994 * @tc.name : call OH_VideoProcessingCallback_BindOnNewOutputBuffer
995 * @tc.desc : function test
996 */
997 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0520, TestSize.Level0)
998 {
999 OH_VideoProcessing_InitializeEnvironment();
1000 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(
1001 nullptr, OnNewOutputBufferCallback);
1002 ASSERT_EQ(ret, VIDEO_PROCESSING_ERROR_INVALID_PARAMETER);
1003 }
1004
1005 /**
1006 * @tc.number : VPE_VIDEO_API_TEST_0530
1007 * @tc.name : call OH_VideoProcessingCallback_BindOnNewOutputBuffer
1008 * @tc.desc : function test
1009 */
1010 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0530, TestSize.Level0)
1011 {
1012 OH_VideoProcessing_InitializeEnvironment();
1013 VideoProcessing_Callback* callback = nullptr;
1014 VideoProcessing_ErrorCode ret = OH_VideoProcessingCallback_Create(&callback);
1015 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1016 ret = OH_VideoProcessingCallback_BindOnNewOutputBuffer(callback, OnNewOutputBufferCallback);
1017 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1018 OH_VideoProcessingCallback_Destroy(callback);
1019 }
1020
1021 /**
1022 * @tc.number : VPE_VIDEO_API_TEST_0540
1023 * @tc.name : call OH_VideoProcessing_Create
1024 * @tc.desc : function test
1025 */
1026 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0540, TestSize.Level0)
1027 {
1028 OH_VideoProcessing_InitializeEnvironment();
1029 OH_VideoProcessing* videoProcessor = nullptr;
1030 VideoProcessing_ErrorCode ret = OH_VideoProcessing_Create(&videoProcessor,
1031 VIDEO_PROCESSING_TYPE_COLOR_SPACE_CONVERSION);
1032 if (g_suppported) {
1033 ASSERT_EQ(ret, VIDEO_PROCESSING_SUCCESS);
1034 OH_VideoProcessing_Destroy(videoProcessor);
1035 } else {
1036 ASSERT_NE(ret, VIDEO_PROCESSING_SUCCESS);
1037 }
1038 }
1039
1040 /**
1041 * @tc.number : VPE_VIDEO_API_TEST_0550
1042 * @tc.name : call OH_VideoProcessing_IsColorSpaceConversionSupported HLG FULL to BT709 Limit NV12
1043 * @tc.desc : function test
1044 */
1045 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0550, TestSize.Level0)
1046 {
1047 OH_VideoProcessing_InitializeEnvironment();
1048 VideoProcessing_ColorSpaceInfo fullInfo = {OH_VIDEO_HDR_VIVID,
1049 OH_COLORSPACE_BT2020_HLG_FULL,
1050 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010};
1051 VideoProcessing_ColorSpaceInfo dstInfo = {OH_VIDEO_NONE,
1052 OH_COLORSPACE_BT709_LIMIT,
1053 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP};
1054 bool ret = OH_VideoProcessing_IsColorSpaceConversionSupported(&fullInfo, &dstInfo);
1055 if (g_suppported) {
1056 ASSERT_TRUE(ret);
1057 } else {
1058 ASSERT_FALSE(ret);
1059 }
1060 }
1061
1062 /**
1063 * @tc.number : VPE_VIDEO_API_TEST_0560
1064 * @tc.name : call OH_VideoProcessing_IsColorSpaceConversionSupported HLG FULL to BT709 Limit NV21
1065 * @tc.desc : function test
1066 */
1067 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0560, TestSize.Level0)
1068 {
1069 OH_VideoProcessing_InitializeEnvironment();
1070 VideoProcessing_ColorSpaceInfo fullInfo = {OH_VIDEO_HDR_VIVID,
1071 OH_COLORSPACE_BT2020_HLG_FULL,
1072 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010};
1073 VideoProcessing_ColorSpaceInfo dstInfo = {OH_VIDEO_NONE,
1074 OH_COLORSPACE_BT709_LIMIT,
1075 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP};
1076 bool ret = OH_VideoProcessing_IsColorSpaceConversionSupported(&fullInfo, &dstInfo);
1077 if (g_suppported) {
1078 ASSERT_TRUE(ret);
1079 } else {
1080 ASSERT_FALSE(ret);
1081 }
1082 }
1083
1084 /**
1085 * @tc.number : VPE_VIDEO_API_TEST_0570
1086 * @tc.name : call OH_VideoProcessing_IsColorSpaceConversionSupported HLG FULL to BT709 Limit NV12
1087 * @tc.desc : function test
1088 */
1089 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0570, TestSize.Level0)
1090 {
1091 OH_VideoProcessing_InitializeEnvironment();
1092 VideoProcessing_ColorSpaceInfo fullInfo = {OH_VIDEO_HDR_VIVID,
1093 OH_COLORSPACE_BT2020_HLG_FULL,
1094 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010};
1095 VideoProcessing_ColorSpaceInfo dstInfo = {OH_VIDEO_NONE,
1096 OH_COLORSPACE_BT709_LIMIT,
1097 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP};
1098 bool ret = OH_VideoProcessing_IsColorSpaceConversionSupported(&fullInfo, &dstInfo);
1099 if (g_suppported) {
1100 ASSERT_TRUE(ret);
1101 } else {
1102 ASSERT_FALSE(ret);
1103 }
1104 }
1105
1106 /**
1107 * @tc.number : VPE_VIDEO_API_TEST_0580
1108 * @tc.name : call OH_VideoProcessing_IsColorSpaceConversionSupported HLG FULL to BT709 Limit NV21
1109 * @tc.desc : function test
1110 */
1111 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0580, TestSize.Level0)
1112 {
1113 OH_VideoProcessing_InitializeEnvironment();
1114 VideoProcessing_ColorSpaceInfo fullInfo = {OH_VIDEO_HDR_VIVID,
1115 OH_COLORSPACE_BT2020_HLG_FULL,
1116 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010};
1117 VideoProcessing_ColorSpaceInfo dstInfo = {OH_VIDEO_NONE,
1118 OH_COLORSPACE_BT709_LIMIT,
1119 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP};
1120 bool ret = OH_VideoProcessing_IsColorSpaceConversionSupported(&fullInfo, &dstInfo);
1121 if (g_suppported) {
1122 ASSERT_TRUE(ret);
1123 } else {
1124 ASSERT_FALSE(ret);
1125 }
1126 }
1127 /**
1128 * @tc.number : VPE_VIDEO_API_TEST_0590
1129 * @tc.name : call OH_VideoProcessing_IsColorSpaceConversionSupported HLG FULL to BT709 Limit NV21
1130 * @tc.desc : function test
1131 */
1132 HWTEST_F(VpeVideoApiTest, VPE_VIDEO_API_TEST_0590, TestSize.Level0)
1133 {
1134 OH_VideoProcessing_InitializeEnvironment();
1135 VideoProcessing_ColorSpaceInfo fullInfo = {OH_VIDEO_HDR_HLG,
1136 OH_COLORSPACE_BT2020_HLG_FULL,
1137 NATIVEBUFFER_PIXEL_FMT_YCRCB_P010};
1138 VideoProcessing_ColorSpaceInfo dstInfo = {OH_VIDEO_NONE,
1139 OH_COLORSPACE_BT709_LIMIT,
1140 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP};
1141 bool ret = OH_VideoProcessing_IsColorSpaceConversionSupported(&fullInfo, &dstInfo);
1142 ASSERT_FALSE(ret);
1143 }
1144 }