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 <iostream>
17 #include <cstdio>
18
19 #include <atomic>
20 #include <fstream>
21 #include <thread>
22 #include <mutex>
23 #include <queue>
24 #include <string>
25
26 #include "gtest/gtest.h"
27 #include "videodec_sample.h"
28 #include "native_avcodec_videodecoder.h"
29 #include "native_avformat.h"
30 #include "native_averrors.h"
31 #include "native_avcodec_base.h"
32 #include "native_avcapability.h"
33
34 #ifdef SUPPORT_DRM
35 #include "native_mediakeysession.h"
36 #include "native_mediakeysystem.h"
37 #endif
38
39 #define PIXFORMAT_NUM 4
40
41 using namespace std;
42 using namespace OHOS;
43 using namespace OHOS::Media;
44 using namespace testing::ext;
45 namespace OHOS {
46 namespace Media {
47 class Mpeg4SwdecApiNdkTest : public testing::Test {
48 public:
49 // SetUpTestCase: Called before all test cases
50 static void SetUpTestCase(void);
51 // TearDownTestCase: Called after all test case
52 static void TearDownTestCase(void);
53 // SetUp: Called before each test cases
54 void SetUp(void);
55 // TearDown: Called after each test cases
56 void TearDown(void);
57 };
58
59 OH_AVCodec *vdec_ = NULL;
60 OH_AVCapability *cap = nullptr;
61 const string INVALID_CODEC_NAME = "avdec_mpeg2";
62 const string CODEC_NAME = "OH.Media.Codec.Decoder.Video.MPEG4";
63 VDecSignal *signal_;
64 constexpr uint32_t DEFAULT_WIDTH = 1920;
65 constexpr uint32_t DEFAULT_HEIGHT = 1080;
66 constexpr uint32_t DEFAULT_FRAME_RATE = 30;
67 constexpr uint8_t ERROR_LEVEL = 10;
68 OH_AVFormat *format;
SetUpTestCase()69 void Mpeg4SwdecApiNdkTest::SetUpTestCase() {}
TearDownTestCase()70 void Mpeg4SwdecApiNdkTest::TearDownTestCase() {}
SetUp()71 void Mpeg4SwdecApiNdkTest::SetUp()
72 {
73 signal_ = new VDecSignal();
74 }
TearDown()75 void Mpeg4SwdecApiNdkTest::TearDown()
76 {
77 if (format != nullptr) {
78 OH_AVFormat_Destroy(format);
79 format = nullptr;
80 }
81 if (signal_) {
82 delete signal_;
83 signal_ = nullptr;
84 }
85 if (vdec_ != NULL) {
86 OH_VideoDecoder_Destroy(vdec_);
87 vdec_ = nullptr;
88 }
89 }
90 } // namespace Media
91 } // namespace OHOS
92
93 namespace {
94 /**
95 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0100
96 * @tc.name : OH_VideoDecoder_CreateByName para error
97 * @tc.desc : function test
98 */
99 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0100, TestSize.Level2)
100 {
101 vdec_ = OH_VideoDecoder_CreateByName(NULL);
102 ASSERT_EQ(NULL, vdec_);
103 }
104
105 /**
106 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0200
107 * @tc.name : OH_VideoDecoder_CreateByMime para error
108 * @tc.desc : function test
109 */
110 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0200, TestSize.Level2)
111 {
112 vdec_ = OH_VideoDecoder_CreateByMime(NULL);
113 ASSERT_EQ(NULL, vdec_);
114 }
115
116 /**
117 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0300
118 * @tc.name : OH_VideoDecoder_SetCallback para error
119 * @tc.desc : function test
120 */
121 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0300, TestSize.Level2)
122 {
123 OH_AVCodecAsyncCallback cb_;
124 cb_.onError = VdecError;
125 cb_.onStreamChanged = VdecFormatChanged;
126 cb_.onNeedInputData = VdecInputDataReady;
127 cb_.onNeedOutputData = VdecOutputDataReady;
128
129 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetCallback(NULL, cb_, static_cast<void *>(signal_)));
130 }
131
132 /**
133 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0400
134 * @tc.name : OH_VideoDecoder_SetCallback para error
135 * @tc.desc : function test
136 */
137 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0400, TestSize.Level2)
138 {
139 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
140 ASSERT_NE(NULL, vdec_);
141
142 OH_AVCodecAsyncCallback cb2_;
143 cb2_.onError = NULL;
144 cb2_.onStreamChanged = NULL;
145 cb2_.onNeedInputData = NULL;
146 cb2_.onNeedOutputData = NULL;
147 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb2_, static_cast<void *>(signal_)));
148 }
149
150 /**
151 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0500
152 * @tc.name : OH_VideoDecoder_SetCallback para error
153 * @tc.desc : function test
154 */
155 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0500, TestSize.Level2)
156 {
157 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
158 OH_AVCodecAsyncCallback cb_;
159 cb_.onError = VdecError;
160 cb_.onStreamChanged = VdecFormatChanged;
161 cb_.onNeedInputData = VdecInputDataReady;
162 cb_.onNeedOutputData = VdecOutputDataReady;
163 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
164 }
165
166 /**
167 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0600
168 * @tc.name : OH_VideoDecoder_Destroy para error
169 * @tc.desc : function test
170 */
171 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0600, TestSize.Level2)
172 {
173 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Destroy(NULL));
174 }
175
176 /**
177 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0700
178 * @tc.name : OH_VideoDecoder_Configure para error
179 * @tc.desc : function test
180 */
181 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0700, TestSize.Level2)
182 {
183 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
184 ASSERT_NE(NULL, vdec_);
185 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, NULL));
186 }
187
188 /**
189 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0800
190 * @tc.name : OH_VideoDecoder_Configure para error
191 * @tc.desc : function test
192 */
193 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0800, TestSize.Level2)
194 {
195 OH_AVFormat *format = OH_AVFormat_Create();
196 ASSERT_NE(NULL, format);
197 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
198 }
199
200 /**
201 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0900
202 * @tc.name : OH_VideoDecoder_Configure para error
203 * @tc.desc : function test
204 */
205 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_0900, TestSize.Level2)
206 {
207 OH_AVFormat *format = OH_AVFormat_Create();
208 ASSERT_NE(NULL, format);
209
210 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
211 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
212 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
213 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
214 }
215
216 /**
217 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1000
218 * @tc.name : OH_VideoDecoder_Start para error
219 * @tc.desc : function test
220 */
221 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1000, TestSize.Level2)
222 {
223 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Start(NULL));
224 }
225
226 /**
227 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1100
228 * @tc.name : OH_VideoDecoder_Stop para error
229 * @tc.desc : function test
230 */
231 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1100, TestSize.Level2)
232 {
233 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Stop(NULL));
234 }
235
236 /**
237 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1200
238 * @tc.name : OH_VideoDecoder_Flush para error
239 * @tc.desc : function test
240 */
241 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1200, TestSize.Level2)
242 {
243 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Flush(NULL));
244 }
245
246 /**
247 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1300
248 * @tc.name : OH_VideoDecoder_Reset para error
249 * @tc.desc : function test
250 */
251 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1300, TestSize.Level2)
252 {
253 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Reset(NULL));
254 }
255
256 /**
257 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1400
258 * @tc.name : OH_VideoDecoder_GetOutputDescription para error
259 * @tc.desc : function test
260 */
261 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1400, TestSize.Level2)
262 {
263 ASSERT_EQ(NULL, OH_VideoDecoder_GetOutputDescription(NULL));
264 }
265
266 /**
267 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1500
268 * @tc.name : OH_VideoDecoder_SetParameter para error
269 * @tc.desc : function test
270 */
271 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1500, TestSize.Level2)
272 {
273 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
274 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetParameter(vdec_, NULL));
275 }
276
277 /**
278 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1600
279 * @tc.name : OH_VideoDecoder_Prepare para error
280 * @tc.desc : function test
281 */
282 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1600, TestSize.Level2)
283 {
284 OH_AVErrCode ret = AV_ERR_OK;
285 ret = OH_VideoDecoder_Prepare(nullptr);
286 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
287 }
288
289 /**
290 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1700
291 * @tc.name : OH_VideoDecoder_SetParameter para error
292 * @tc.desc : function test
293 */
294 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1700, TestSize.Level2)
295 {
296 OH_AVFormat *format = OH_AVFormat_Create();
297 ASSERT_NE(NULL, format);
298
299 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
300 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
301 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
302 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetParameter(NULL, format));
303 }
304
305 /**
306 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1800
307 * @tc.name : OH_VideoDecoder_SetSurface para error
308 * @tc.desc : function test
309 */
310 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1800, TestSize.Level2)
311 {
312 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
313 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetSurface(vdec_, NULL));
314 }
315
316 /**
317 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1900
318 * @tc.name : OH_VideoDecoder_CreateByName para error
319 * @tc.desc : function test
320 */
321 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_1900, TestSize.Level2)
322 {
323 vdec_ = OH_VideoDecoder_CreateByName(INVALID_CODEC_NAME.c_str());
324 ASSERT_EQ(NULL, vdec_);
325 }
326
327 /**
328 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2000
329 * @tc.name : OH_VideoDecoder_CreateByMime para error
330 * @tc.desc : function test
331 */
332 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2000, TestSize.Level2)
333 {
334 vdec_ = OH_VideoDecoder_CreateByMime(INVALID_CODEC_NAME.c_str());
335 ASSERT_EQ(NULL, vdec_);
336 }
337
338 /**
339 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2100
340 * @tc.name : OH_VideoDecoder_RenderOutputData para error
341 * @tc.desc : function test
342 */
343 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2100, TestSize.Level2)
344 {
345 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
346 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_RenderOutputData(vdec_, 0));
347 }
348
349 /**
350 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2200
351 * @tc.name : OH_VideoDecoder_FreeOutputData para error
352 * @tc.desc : function test
353 */
354 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2200, TestSize.Level2)
355 {
356 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_FreeOutputData(NULL, 0));
357 }
358
359 /**
360 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2300
361 * @tc.name : OH_VideoDecoder_FreeOutputData para error
362 * @tc.desc : function test
363 */
364 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2300, TestSize.Level2)
365 {
366 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
367 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_FreeOutputData(vdec_, 0));
368 }
369
370 /**
371 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2400
372 * @tc.name : OH_VideoDecoder_FreeOutputData para error
373 * @tc.desc : function test
374 */
375 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2400, TestSize.Level2)
376 {
377 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
378 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_FreeOutputData(vdec_, -1));
379 }
380
381 /**
382 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2500
383 * @tc.name : OH_VideoDecoder_PushInputData para error
384 * @tc.desc : function test
385 */
386 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2500, TestSize.Level2)
387 {
388 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
389
390 OH_AVCodecBufferAttr attr;
391 attr.pts = -1;
392 attr.size = -1;
393 attr.offset = -1;
394 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
395
396 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(vdec_, 0, attr));
397 }
398
399 /**
400 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2600
401 * @tc.name : OH_VideoDecoder_PushInputData para error
402 * @tc.desc : function test
403 */
404 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2600, TestSize.Level2)
405 {
406 OH_AVCodecBufferAttr attr;
407 attr.pts = 0;
408 attr.size = 0;
409 attr.offset = 0;
410 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
411
412 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(NULL, -1, attr));
413 }
414
415 /**
416 * @tc.number : VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2700
417 * @tc.name : OH_VideoDecoder_PushInputData para error
418 * @tc.desc : function test
419 */
420 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_ILLEGAL_PARA_2700, TestSize.Level2)
421 {
422 OH_AVCodecBufferAttr attr;
423 attr.pts = 0;
424 attr.size = 0;
425 attr.offset = 0;
426 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
427
428 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(NULL, 0, attr));
429 }
430
431 /**
432 * @tc.number : VIDEO_MPEG4SWDEC_API_0100
433 * @tc.name : repeat create OH_VideoDecoder_CreateByName
434 * @tc.desc : function test
435 */
436 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_API_0100, TestSize.Level2)
437 {
438 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
439 ASSERT_NE(vdec_, NULL);
440 OH_AVCodec *vdec_2 = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
441 ASSERT_NE(vdec_2, NULL);
442 OH_VideoDecoder_Destroy(vdec_2);
443 vdec_2 = nullptr;
444 }
445
446 /**
447 * @tc.number : VIDEO_MPEG4SWDEC_API_0200
448 * @tc.name : repeat create OH_VideoDecoder_CreateByMime
449 * @tc.desc : function test
450 */
451 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_API_0200, TestSize.Level2)
452 {
453 vdec_ = OH_VideoDecoder_CreateByMime("video/mp4v-es");
454 ASSERT_NE(vdec_, NULL);
455 OH_AVCodec *vdec_2 = OH_VideoDecoder_CreateByMime("video/mp4v-es");
456 ASSERT_NE(vdec_2, NULL);
457 OH_VideoDecoder_Destroy(vdec_2);
458 vdec_2 = nullptr;
459 }
460
461
462 /**
463 * @tc.number : VIDEO_MPEG4SWDEC_API_0300
464 * @tc.name : create configure configure
465 * @tc.desc : function test
466 */
467 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_API_0300, TestSize.Level2)
468 {
469 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
470 ASSERT_NE(NULL, vdec_);
471
472 OH_AVFormat *format = OH_AVFormat_Create();
473 ASSERT_NE(NULL, format);
474
475 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
476 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
477 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
478
479 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
480 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Configure(vdec_, format));
481 }
482
483 /**
484 * @tc.number : VIDEO_MPEG4SWDEC_API_0400
485 * @tc.name : create configure start start
486 * @tc.desc : function test
487 */
488 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_API_0400, TestSize.Level2)
489 {
490 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
491 ASSERT_NE(NULL, vdec_);
492
493 OH_AVFormat *format = OH_AVFormat_Create();
494 ASSERT_NE(NULL, format);
495
496 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
497 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
498 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
499
500 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
501 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
502 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Start(vdec_));
503 }
504
505 /**
506 * @tc.number : VIDEO_MPEG4SWDEC_API_0500
507 * @tc.name : create configure start stop stop
508 * @tc.desc : function test
509 */
510 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_API_0500, TestSize.Level2)
511 {
512 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
513 ASSERT_NE(NULL, vdec_);
514
515 OH_AVFormat *format = OH_AVFormat_Create();
516 ASSERT_NE(NULL, format);
517
518 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
519 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
520 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
521
522 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
523 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
524 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
525 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
526 }
527
528 /**
529 * @tc.number : VIDEO_MPEG4SWDEC_API_0600
530 * @tc.name : create configure start stop reset reset
531 * @tc.desc : function test
532 */
533 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_API_0600, TestSize.Level2)
534 {
535 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
536 ASSERT_NE(NULL, vdec_);
537
538 OH_AVFormat *format = OH_AVFormat_Create();
539 ASSERT_NE(NULL, format);
540
541 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
542 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
543 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
544
545 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
546 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
547 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
548 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
549 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
550 }
551
552 /**
553 * @tc.number : VIDEO_MPEG4SWDEC_API_0700
554 * @tc.name : create configure start EOS EOS
555 * @tc.desc : function test
556 */
557 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_API_0700, TestSize.Level2)
558 {
559 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
560 ASSERT_NE(NULL, vdec_);
561
562 OH_AVFormat *format = OH_AVFormat_Create();
563 ASSERT_NE(NULL, format);
564
565 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
566 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
567 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
568
569 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
570 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
571
572 OH_AVCodecBufferAttr attr;
573 attr.pts = 0;
574 attr.size = 0;
575 attr.offset = 0;
576 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
577
578 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_PushInputData(vdec_, 0, attr));
579 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_PushInputData(vdec_, 0, attr));
580 }
581
582 /**
583 * @tc.number : VIDEO_MPEG4SWDEC_API_0800
584 * @tc.name : create configure start flush flush
585 * @tc.desc : function test
586 */
587 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_API_0800, TestSize.Level2)
588 {
589 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
590 ASSERT_NE(NULL, vdec_);
591
592 OH_AVFormat *format = OH_AVFormat_Create();
593 ASSERT_NE(NULL, format);
594
595 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
596 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
597 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
598
599 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
600 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
601 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
602 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
603 }
604
605 /**
606 * @tc.number : VIDEO_MPEG4SWDEC_API_0900
607 * @tc.name : create configure start stop release release
608 * @tc.desc : function test
609 */
610 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_API_0900, TestSize.Level2)
611 {
612 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
613 ASSERT_NE(NULL, vdec_);
614
615 OH_AVFormat *format = OH_AVFormat_Create();
616 ASSERT_NE(NULL, format);
617
618 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
619 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
620 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
621
622 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
623 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
624 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
625 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Destroy(vdec_));
626 vdec_ = nullptr;
627 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Destroy(vdec_));
628 }
629
630 /**
631 * @tc.number : VIDEO_MPEG4SWDEC_API_1000
632 * @tc.name : repeat OH_VideoDecoder_SetCallback
633 * @tc.desc : function test
634 */
635 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_API_1000, TestSize.Level2)
636 {
637 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
638 OH_AVCodecAsyncCallback cb_;
639 cb_.onError = VdecError;
640 cb_.onStreamChanged = VdecFormatChanged;
641 cb_.onNeedInputData = VdecInputDataReady;
642 cb_.onNeedOutputData = VdecOutputDataReady;
643 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
644 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
645 }
646
647 /**
648 * @tc.number : VIDEO_MPEG4SWDEC_API_1100
649 * @tc.name : repeat OH_VideoDecoder_GetOutputDescription
650 * @tc.desc : function test
651 */
652 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_API_1100, TestSize.Level2)
653 {
654 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
655 OH_AVFormat *format = OH_VideoDecoder_GetOutputDescription(vdec_);
656 ASSERT_NE(NULL, format);
657 format = OH_VideoDecoder_GetOutputDescription(vdec_);
658 ASSERT_NE(NULL, format);
659 }
660
661 /**
662 * @tc.number : VIDEO_MPEG4SWDEC_API_1200
663 * @tc.name : repeat OH_VideoDecoder_SetParameter
664 * @tc.desc : function test
665 */
666 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_API_1200, TestSize.Level2)
667 {
668 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
669 ASSERT_NE(NULL, vdec_);
670
671 OH_AVFormat *format = OH_AVFormat_Create();
672 ASSERT_NE(NULL, format);
673
674 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
675 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
676 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
677
678 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_SetParameter(vdec_, format));
679 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_SetParameter(vdec_, format));
680 }
681
682 /**
683 * @tc.number : VIDEO_MPEG4SWDEC_CAP_0100
684 * @tc.name : OH_AVCodec_GetCapability
685 * @tc.desc : function test
686 */
687 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_0100, TestSize.Level2)
688 {
689 cap = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2, false);
690 ASSERT_NE(cap, nullptr);
691 }
692
693 /**
694 * @tc.number : VIDEO_MPEG4SWDEC_CAP_0200
695 * @tc.name : OH_AVCodec_GetCapabilityByCategory
696 * @tc.desc : function test
697 */
698 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_0200, TestSize.Level2)
699 {
700 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2, false, SOFTWARE);
701 ASSERT_NE(cap, nullptr);
702 }
703
704 /**
705 * @tc.number : VIDEO_MPEG4SWDEC_CAP_0300
706 * @tc.name : OH_AVCodec_GetCapabilityByCategory
707 * @tc.desc : function test
708 */
709 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_0300, TestSize.Level2)
710 {
711 cap = OH_AVCodec_GetCapabilityByCategory(nullptr, false, SOFTWARE);
712 ASSERT_EQ(cap, nullptr);
713 }
714
715 /**
716 * @tc.number : VIDEO_MPEG4SWDEC_CAP_0400
717 * @tc.name : OH_AVCodec_GetCapabilityByCategory
718 * @tc.desc : function test
719 */
720 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_0400, TestSize.Level2)
721 {
722 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2, false, SOFTWARE);
723 ASSERT_NE(cap, nullptr);
724 ASSERT_FALSE(OH_AVCapability_IsHardware(cap));
725 }
726
727 /**
728 * @tc.number : VIDEO_MPEG4SWDEC_CAP_0500
729 * @tc.name : OH_AVCapability_IsHardware
730 * @tc.desc : function test
731 */
732 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_0500, TestSize.Level2)
733 {
734 ASSERT_FALSE(OH_AVCapability_IsHardware(nullptr));
735 }
736
737 /**
738 * @tc.number : VIDEO_MPEG4SWDEC_CAP_0600
739 * @tc.name : OH_AVCapability_GetMaxSupportedInstances
740 * @tc.desc : function test
741 */
742 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_0600, TestSize.Level2)
743 {
744 ASSERT_EQ(0, OH_AVCapability_GetMaxSupportedInstances(nullptr));
745 }
746
747 /**
748 * @tc.number : VIDEO_MPEG4SWDEC_CAP_0700
749 * @tc.name : OH_AVCapability_GetMaxSupportedInstances
750 * @tc.desc : function test
751 */
752 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_0700, TestSize.Level2)
753 {
754 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2, false, SOFTWARE);
755 ASSERT_NE(cap, nullptr);
756 ASSERT_EQ(64, OH_AVCapability_GetMaxSupportedInstances(cap));
757 }
758
759 /**
760 * @tc.number : VIDEO_MPEG4SWDEC_CAP_0800
761 * @tc.name : OH_AVCapability_GetName
762 * @tc.desc : function test
763 */
764 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_0800, TestSize.Level2)
765 {
766 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2, false, SOFTWARE);
767 ASSERT_NE(cap, nullptr);
768 ASSERT_EQ(CODEC_NAME, OH_AVCapability_GetName(cap));
769 }
770
771 /**
772 * @tc.number : VIDEO_MPEG4SWDEC_CAP_0900
773 * @tc.name : OH_AVCapability_GetName
774 * @tc.desc : function test
775 */
776 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_0900, TestSize.Level2)
777 {
778 const char *name = OH_AVCapability_GetName(nullptr);
779 int ret = strcmp("", name);
780 ASSERT_EQ(0, ret);
781 }
782
783 /**
784 * @tc.number : VIDEO_MPEG4SWDEC_CAP_1000
785 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
786 * @tc.desc : api test
787 */
788 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_1000, TestSize.Level2)
789 {
790 OH_AVErrCode ret = AV_ERR_OK;
791 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
792 false, SOFTWARE);
793 ASSERT_NE(nullptr, capability);
794 ret = OH_AVCapability_GetVideoWidthAlignment(capability, nullptr);
795 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
796 }
797
798 /**
799 * @tc.number : VIDEO_MPEG4SWDEC_CAP_1100
800 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
801 * @tc.desc : api test
802 */
803 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_1100, TestSize.Level2)
804 {
805 OH_AVErrCode ret = AV_ERR_OK;
806 int32_t alignment = 0;
807 ret = OH_AVCapability_GetVideoWidthAlignment(nullptr, &alignment);
808 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
809 }
810
811 /**
812 * @tc.number : VIDEO_MPEG4SWDEC_CAP_1200
813 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param correct
814 * @tc.desc : api test
815 */
816 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_1200, TestSize.Level2)
817 {
818 OH_AVErrCode ret = AV_ERR_OK;
819 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
820 false, SOFTWARE);
821 ASSERT_NE(nullptr, capability);
822 int32_t alignment = 0;
823 ret = OH_AVCapability_GetVideoWidthAlignment(capability, &alignment);
824 cout << "WidthAlignment " << alignment << endl;
825 ASSERT_EQ(AV_ERR_OK, ret);
826 ASSERT_GE(alignment, 0);
827 }
828
829 /**
830 * @tc.number : VIDEO_MPEG4SWDEC_CAP_1300
831 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
832 * @tc.desc : api test
833 */
834 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_1300, TestSize.Level2)
835 {
836 OH_AVErrCode ret = AV_ERR_OK;
837 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
838 false, SOFTWARE);
839 ASSERT_NE(nullptr, capability);
840 ret = OH_AVCapability_GetVideoHeightAlignment(capability, nullptr);
841 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
842 }
843
844 /**
845 * @tc.number : VIDEO_MPEG4SWDEC_CAP_1400
846 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
847 * @tc.desc : api test
848 */
849 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_1400, TestSize.Level2)
850 {
851 OH_AVErrCode ret = AV_ERR_OK;
852 int32_t alignment = 0;
853 ret = OH_AVCapability_GetVideoHeightAlignment(nullptr, &alignment);
854 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
855 }
856
857 /**
858 * @tc.number : VIDEO_MPEG4SWDEC_CAP_1500
859 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param correct
860 * @tc.desc : api test
861 */
862 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_1500, TestSize.Level2)
863 {
864 OH_AVErrCode ret = AV_ERR_OK;
865 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
866 false, SOFTWARE);
867 ASSERT_NE(nullptr, capability);
868 int32_t alignment = 0;
869 ret = OH_AVCapability_GetVideoHeightAlignment(capability, &alignment);
870 cout << "HeightAlignment " << alignment << endl;
871 ASSERT_EQ(AV_ERR_OK, ret);
872 ASSERT_GE(alignment, 0);
873 }
874
875 /**
876 * @tc.number : VIDEO_MPEG4SWDEC_CAP_1600
877 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
878 * @tc.desc : api test
879 */
880 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_1600, TestSize.Level2)
881 {
882 OH_AVErrCode ret = AV_ERR_OK;
883 OH_AVRange range;
884 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
885 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
886 false, SOFTWARE);
887 ASSERT_NE(nullptr, capability);
888 ret = OH_AVCapability_GetVideoWidthRangeForHeight(nullptr, DEFAULT_HEIGHT, &range);
889 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
890 }
891
892 /**
893 * @tc.number : VIDEO_MPEG4SWDEC_CAP_1700
894 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
895 * @tc.desc : api test
896 */
897 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_1700, TestSize.Level2)
898 {
899 OH_AVErrCode ret = AV_ERR_OK;
900 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
901 false, SOFTWARE);
902 ASSERT_NE(nullptr, capability);
903 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, nullptr);
904 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
905 }
906
907 /**
908 * @tc.number : VIDEO_MPEG4SWDEC_CAP_1800
909 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
910 * @tc.desc : api test
911 */
912 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_1800, TestSize.Level2)
913 {
914 OH_AVErrCode ret = AV_ERR_OK;
915 OH_AVRange range;
916 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
917 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
918 false, SOFTWARE);
919 ASSERT_NE(nullptr, capability);
920 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 0, &range);
921 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
922 }
923
924 /**
925 * @tc.number : VIDEO_MPEG4SWDEC_CAP_1900
926 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
927 * @tc.desc : api test
928 */
929 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_1900, TestSize.Level2)
930 {
931 OH_AVErrCode ret = AV_ERR_OK;
932 OH_AVRange range;
933 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
934 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
935 false, SOFTWARE);
936 ASSERT_NE(nullptr, capability);
937 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
938 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
939 ASSERT_EQ(AV_ERR_OK, ret);
940 ASSERT_EQ(true, (range.minVal >= 0));
941 ASSERT_EQ(true, (range.maxVal > 0));
942 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2);
943 ASSERT_NE(nullptr, vdec_);
944 format = OH_AVFormat_Create();
945 ASSERT_NE(nullptr, format);
946 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
947 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
948 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
949 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
950 OH_VideoDecoder_Destroy(vdec_);
951 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2);
952 ASSERT_NE(nullptr, vdec_);
953 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
954 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
955 }
956
957 /**
958 * @tc.number : VIDEO_MPEG4SWDEC_CAP_2000
959 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
960 * @tc.desc : api test
961 */
962 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_2000, TestSize.Level2)
963 {
964 OH_AVErrCode ret = AV_ERR_OK;
965 OH_AVRange range;
966 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
967 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
968 false, SOFTWARE);
969 ASSERT_NE(nullptr, capability);
970 ret = OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, DEFAULT_WIDTH, &range);
971 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
972 }
973
974 /**
975 * @tc.number : VIDEO_MPEG4SWDEC_CAP_2100
976 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
977 * @tc.desc : api test
978 */
979 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_2100, TestSize.Level2)
980 {
981 OH_AVErrCode ret = AV_ERR_OK;
982 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
983 false, SOFTWARE);
984 ASSERT_NE(nullptr, capability);
985 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, nullptr);
986 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
987 }
988
989 /**
990 * @tc.number : VIDEO_MPEG4SWDEC_CAP_2200
991 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
992 * @tc.desc : api test
993 */
994 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_2200, TestSize.Level2)
995 {
996 OH_AVErrCode ret = AV_ERR_OK;
997 OH_AVRange range;
998 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
999 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1000 false, SOFTWARE);
1001 ASSERT_NE(nullptr, capability);
1002 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
1003 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1004 }
1005
1006 /**
1007 * @tc.number : VIDEO_MPEG4SWDEC_CAP_2300
1008 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
1009 * @tc.desc : api test
1010 */
1011 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_2300, TestSize.Level2)
1012 {
1013 OH_AVErrCode ret = AV_ERR_OK;
1014 OH_AVRange range;
1015 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1016 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1017 false, SOFTWARE);
1018 ASSERT_NE(nullptr, capability);
1019 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
1020 ASSERT_EQ(AV_ERR_OK, ret);
1021 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1022 ASSERT_EQ(true, (range.minVal >= 0));
1023 ASSERT_EQ(true, (range.maxVal > 0));
1024 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2);
1025 ASSERT_NE(nullptr, vdec_);
1026 format = OH_AVFormat_Create();
1027 ASSERT_NE(nullptr, format);
1028 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1029 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1030 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
1031 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1032 OH_VideoDecoder_Destroy(vdec_);
1033 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2);
1034 ASSERT_NE(nullptr, vdec_);
1035 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
1036 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1037 }
1038
1039 /**
1040 * @tc.number : VIDEO_MPEG4SWDEC_CAP_2400
1041 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1042 * @tc.desc : api test
1043 */
1044 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_2400, TestSize.Level2)
1045 {
1046 OH_AVErrCode ret = AV_ERR_OK;
1047 OH_AVRange range;
1048 ret = OH_AVCapability_GetVideoWidthRange(nullptr, &range);
1049 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1050 }
1051
1052 /**
1053 * @tc.number : VIDEO_MPEG4SWDEC_CAP_2500
1054 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1055 * @tc.desc : api test
1056 */
1057 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_2500, TestSize.Level2)
1058 {
1059 OH_AVErrCode ret = AV_ERR_OK;
1060 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1061 false, SOFTWARE);
1062 ASSERT_NE(nullptr, capability);
1063 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
1064 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1065 }
1066
1067 /**
1068 * @tc.number : VIDEO_MPEG4SWDEC_CAP_2600
1069 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
1070 * @tc.desc : api test
1071 */
1072 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_2600, TestSize.Level2)
1073 {
1074 OH_AVErrCode ret = AV_ERR_OK;
1075 OH_AVRange range;
1076 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1077 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1078 false, SOFTWARE);
1079 ASSERT_NE(nullptr, capability);
1080 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1081 ASSERT_EQ(AV_ERR_OK, ret);
1082 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1083 ASSERT_GE(range.minVal, 0);
1084 ASSERT_GT(range.maxVal, 0);
1085 }
1086
1087 /**
1088 * @tc.number : VIDEO_MPEG4SWDEC_CAP_2700
1089 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1090 * @tc.desc : api test
1091 */
1092 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_2700, TestSize.Level2)
1093 {
1094 OH_AVErrCode ret = AV_ERR_OK;
1095 OH_AVRange range;
1096 ret = OH_AVCapability_GetVideoHeightRange(nullptr, &range);
1097 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1098 }
1099
1100 /**
1101 * @tc.number : VIDEO_MPEG4SWDEC_CAP_2800
1102 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1103 * @tc.desc : api test
1104 */
1105 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_2800, TestSize.Level2)
1106 {
1107 OH_AVErrCode ret = AV_ERR_OK;
1108 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1109 false, SOFTWARE);
1110 ASSERT_NE(nullptr, capability);
1111 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
1112 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1113 }
1114
1115 /**
1116 * @tc.number : VIDEO_MPEG4SWDEC_CAP_2900
1117 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
1118 * @tc.desc : api test
1119 */
1120 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_2900, TestSize.Level2)
1121 {
1122 OH_AVErrCode ret = AV_ERR_OK;
1123 OH_AVRange widthRange;
1124 OH_AVRange heightRange;
1125 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1126 memset_s(&heightRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1127 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1128 false, SOFTWARE);
1129 ASSERT_NE(nullptr, capability);
1130 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
1131 ASSERT_EQ(AV_ERR_OK, ret);
1132 cout << "minval=" << heightRange.minVal << " maxval=" << heightRange.maxVal << endl;
1133 ret = OH_AVCapability_GetVideoWidthRange(capability, &widthRange);
1134 ASSERT_EQ(AV_ERR_OK, ret);
1135 cout << "minval=" << widthRange.minVal << " maxval=" << widthRange.maxVal << endl;
1136 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2);
1137 ASSERT_NE(nullptr, vdec_);
1138 format = OH_AVFormat_Create();
1139 ASSERT_NE(nullptr, format);
1140 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1141 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, widthRange.minVal - 1);
1142 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.minVal - 1);
1143 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1144 OH_VideoDecoder_Destroy(vdec_);
1145 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2);
1146 ASSERT_NE(nullptr, vdec_);
1147 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, widthRange.maxVal + 1);
1148 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.maxVal + 1);
1149 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1150 }
1151
1152 /**
1153 * @tc.number : VIDEO_MPEG4SWDEC_CAP_3000
1154 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1155 * @tc.desc : api test
1156 */
1157 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_3000, TestSize.Level2)
1158 {
1159 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1160 false, SOFTWARE);
1161 ASSERT_NE(nullptr, capability);
1162 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, DEFAULT_HEIGHT));
1163 }
1164
1165 /**
1166 * @tc.number : VIDEO_MPEG4SWDEC_CAP_3100
1167 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1168 * @tc.desc : api test
1169 */
1170 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_3100, TestSize.Level2)
1171 {
1172 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1173 false, SOFTWARE);
1174 ASSERT_NE(nullptr, capability);
1175 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, 0));
1176 }
1177 /**
1178 * @tc.number : VIDEO_MPEG4SWDEC_CAP_3200
1179 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1180 * @tc.desc : api test
1181 */
1182 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_3200, TestSize.Level2)
1183 {
1184 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1185 }
1186 /**
1187 * @tc.number : VIDEO_MPEG4SWDEC_CAP_3300
1188 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1189 * @tc.desc : api test
1190 */
1191 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_3300, TestSize.Level2)
1192 {
1193 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1194 false, SOFTWARE);
1195 ASSERT_NE(nullptr, capability);
1196 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 7680, 4320));
1197 }
1198 /**
1199 * @tc.number : VIDEO_MPEG4SWDEC_CAP_3400
1200 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1201 * @tc.desc : api test
1202 */
1203 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_3400, TestSize.Level2)
1204 {
1205 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1206 false, SOFTWARE);
1207 ASSERT_NE(nullptr, capability);
1208 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1209 }
1210
1211 /**
1212 * @tc.number : VIDEO_MPEG4SWDEC_CAP_3500
1213 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1214 * @tc.desc : api test
1215 */
1216 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_3500, TestSize.Level2)
1217 {
1218 OH_AVErrCode ret = AV_ERR_OK;
1219 OH_AVRange range;
1220 ret = OH_AVCapability_GetVideoFrameRateRange(nullptr, &range);
1221 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1222 }
1223
1224 /**
1225 * @tc.number : VIDEO_MPEG4SWDEC_CAP_3600
1226 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1227 * @tc.desc : api test
1228 */
1229 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_3600, TestSize.Level2)
1230 {
1231 OH_AVErrCode ret = AV_ERR_OK;
1232 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1233 false, SOFTWARE);
1234 ASSERT_NE(nullptr, capability);
1235 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
1236 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1237 }
1238
1239 /**
1240 * @tc.number : VIDEO_MPEG4SWDEC_CAP_3700
1241 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1242 * @tc.desc : api test
1243 */
1244 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_3700, TestSize.Level2)
1245 {
1246 OH_AVErrCode ret = AV_ERR_OK;
1247 OH_AVRange range;
1248 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1249 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1250 false, SOFTWARE);
1251 ASSERT_NE(nullptr, capability);
1252 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1253 ASSERT_EQ(AV_ERR_OK, ret);
1254 ASSERT_GE(range.minVal, 0);
1255 ASSERT_GT(range.maxVal, 0);
1256 }
1257
1258 /**
1259 * @tc.number : VIDEO_MPEG4SWDEC_CAP_3800
1260 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1261 * @tc.desc : api test
1262 */
1263 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_3800, TestSize.Level2)
1264 {
1265 OH_AVErrCode ret = AV_ERR_OK;
1266 OH_AVRange range;
1267 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1268 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1269 }
1270
1271 /**
1272 * @tc.number : VIDEO_MPEG4SWDEC_CAP_3900
1273 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1274 * @tc.desc : api test
1275 */
1276 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_3900, TestSize.Level2)
1277 {
1278 OH_AVErrCode ret = AV_ERR_OK;
1279 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1280 false, SOFTWARE);
1281 ASSERT_NE(nullptr, capability);
1282 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, nullptr);
1283 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1284 }
1285
1286 /**
1287 * @tc.number : VIDEO_MPEG4SWDEC_CAP_4000
1288 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1289 * @tc.desc : api test
1290 */
1291 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_4000, TestSize.Level2)
1292 {
1293 OH_AVErrCode ret = AV_ERR_OK;
1294 OH_AVRange range;
1295 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1296 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1297 false, SOFTWARE);
1298 ASSERT_NE(nullptr, capability);
1299 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, DEFAULT_HEIGHT, &range);
1300 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1301 }
1302
1303 /**
1304 * @tc.number : VIDEO_MPEG4SWDEC_CAP_4100
1305 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1306 * @tc.desc : api test
1307 */
1308 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_4100, TestSize.Level2)
1309 {
1310 OH_AVErrCode ret = AV_ERR_OK;
1311 OH_AVRange range;
1312 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1313 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1314 false, SOFTWARE);
1315 ASSERT_NE(nullptr, capability);
1316 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, 0, &range);
1317 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1318 }
1319
1320 /**
1321 * @tc.number : VIDEO_MPEG4SWDEC_CAP_4200
1322 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1323 * @tc.desc : api test
1324 */
1325 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_4200, TestSize.Level2)
1326 {
1327 OH_AVErrCode ret = AV_ERR_OK;
1328 OH_AVRange range;
1329 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1330 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1331 false, SOFTWARE);
1332 ASSERT_NE(nullptr, capability);
1333 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1280, 720, &range);
1334 ASSERT_EQ(AV_ERR_OK, ret);
1335 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1336 ASSERT_GE(range.minVal, 0);
1337 ASSERT_GT(range.maxVal, 0);
1338
1339 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1340 ASSERT_EQ(AV_ERR_OK, ret);
1341 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1342 ASSERT_GE(range.minVal, 0);
1343 ASSERT_GT(range.maxVal, 0);
1344 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 2, 2, &range);
1345 ASSERT_EQ(AV_ERR_OK, ret);
1346 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1347 ASSERT_GE(range.minVal, 0);
1348 ASSERT_GT(range.maxVal, 0);
1349 }
1350
1351 /**
1352 * @tc.number : VIDEO_MPEG4SWDEC_CAP_4300
1353 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1354 * @tc.desc : api test
1355 */
1356 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_4300, TestSize.Level2)
1357 {
1358 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1359 false, SOFTWARE);
1360 ASSERT_NE(nullptr, capability);
1361 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, DEFAULT_HEIGHT, 30));
1362 }
1363
1364 /**
1365 * @tc.number : VIDEO_MPEG4SWDEC_CAP_4400
1366 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1367 * @tc.desc : api test
1368 */
1369 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_4400, TestSize.Level2)
1370 {
1371 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1372 false, SOFTWARE);
1373 ASSERT_NE(nullptr, capability);
1374 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, 0, 30));
1375 }
1376
1377 /**
1378 * @tc.number : VIDEO_MPEG4SWDEC_CAP_4500
1379 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1380 * @tc.desc : api test
1381 */
1382 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_4500, TestSize.Level2)
1383 {
1384 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1385 false, SOFTWARE);
1386 ASSERT_NE(nullptr, capability);
1387 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 0));
1388 }
1389
1390 /**
1391 * @tc.number : VIDEO_MPEG4SWDEC_CAP_4600
1392 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1393 * @tc.desc : api test
1394 */
1395 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_4600, TestSize.Level2)
1396 {
1397 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1398 }
1399
1400 /**
1401 * @tc.number : VIDEO_MPEG4SWDEC_CAP_4700
1402 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1403 * @tc.desc : api test
1404 */
1405 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_4700, TestSize.Level2)
1406 {
1407 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1408 false, SOFTWARE);
1409 ASSERT_NE(nullptr, capability);
1410 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1411 }
1412
1413 /**
1414 * @tc.number : VIDEO_MPEG4SWDEC_CAP_4800
1415 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1416 * @tc.desc : api test
1417 */
1418 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_4800, TestSize.Level2)
1419 {
1420 OH_AVErrCode ret = AV_ERR_OK;
1421 const int32_t *pixelFormat = nullptr;
1422 uint32_t pixelFormatNum = 0;
1423 ret = OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixelFormat, &pixelFormatNum);
1424 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1425 }
1426
1427 /**
1428 * @tc.number : VIDEO_MPEG4SWDEC_CAP_4900
1429 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1430 * @tc.desc : api test
1431 */
1432 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_4900, TestSize.Level2)
1433 {
1434 OH_AVErrCode ret = AV_ERR_OK;
1435 uint32_t pixelFormatNum = 0;
1436 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1437 false, SOFTWARE);
1438 ASSERT_NE(nullptr, capability);
1439 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
1440 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1441 }
1442
1443 /**
1444 * @tc.number : VIDEO_MPEG4SWDEC_CAP_5000
1445 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1446 * @tc.desc : api test
1447 */
1448 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_5000, TestSize.Level2)
1449 {
1450 OH_AVErrCode ret = AV_ERR_OK;
1451 const int32_t *pixelFormat = nullptr;
1452 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1453 false, SOFTWARE);
1454 ASSERT_NE(nullptr, capability);
1455 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
1456 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1457 }
1458
1459 /**
1460 * @tc.number : VIDEO_MPEG4SWDEC_CAP_5100
1461 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
1462 * @tc.desc : api test
1463 */
1464 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_5100, TestSize.Level2)
1465 {
1466 OH_AVErrCode ret = AV_ERR_OK;
1467 const int32_t *pixelFormat = nullptr;
1468 uint32_t pixelFormatNum = 0;
1469 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1470 false, SOFTWARE);
1471 ASSERT_NE(nullptr, capability);
1472 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
1473 ASSERT_NE(nullptr, pixelFormat);
1474 ASSERT_EQ(pixelFormatNum, PIXFORMAT_NUM);
1475 ASSERT_EQ(AV_ERR_OK, ret);
1476 for (int i = 0; i < pixelFormatNum; i++) {
1477 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
1478 ASSERT_NE(nullptr, vdec_);
1479 format = OH_AVFormat_Create();
1480 ASSERT_NE(nullptr, format);
1481 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1482 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1483 EXPECT_EQ(pixelFormat[i], i == pixelFormatNum - 1 ? i + 2 : i + 1);
1484 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[i]);
1485 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1486 OH_AVFormat_Destroy(format);
1487 OH_VideoDecoder_Destroy(vdec_);
1488 }
1489 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
1490 ASSERT_NE(nullptr, vdec_);
1491 format = OH_AVFormat_Create();
1492 ASSERT_NE(nullptr, format);
1493 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1494 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1495 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
1496 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1497 }
1498
1499 /**
1500 * @tc.number : VIDEO_MPEG4SWDEC_CAP_5200
1501 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
1502 * @tc.desc : api test
1503 */
1504 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_5200, TestSize.Level2)
1505 {
1506 OH_AVErrCode ret = AV_ERR_OK;
1507 const int32_t *profiles = nullptr;
1508 uint32_t profileNum = 0;
1509 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1510 false, SOFTWARE);
1511 ASSERT_NE(nullptr, capability);
1512 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1513 ASSERT_EQ(AV_ERR_OK, ret);
1514 ASSERT_GT(profileNum, 0);
1515 ASSERT_NE(nullptr, profiles);
1516 for (int i = 0; i < profileNum; i++) {
1517 EXPECT_GE(profiles[i], 0);
1518 }
1519 }
1520
1521 /**
1522 * @tc.number : VIDEO_MPEG4SWDEC_CAP_5300
1523 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
1524 * @tc.desc : api test
1525 */
1526 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_5300, TestSize.Level2)
1527 {
1528 OH_AVErrCode ret = AV_ERR_OK;
1529 const int32_t *levels = nullptr;
1530 uint32_t levelNum = 0;
1531 const int32_t *profiles = nullptr;
1532 uint32_t profileNum = 0;
1533 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1534 false, SOFTWARE);
1535 ASSERT_NE(nullptr, capability);
1536 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1537 ASSERT_EQ(AV_ERR_OK, ret);
1538 ASSERT_GT(profileNum, 0);
1539 ASSERT_NE(nullptr, profiles);
1540 for (int i = 0; i < profileNum; i++) {
1541 EXPECT_GE(profiles[i], 0);
1542 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, profiles[i], &levels, &levelNum);
1543 ASSERT_EQ(AV_ERR_OK, ret);
1544 ASSERT_NE(nullptr, levels);
1545 EXPECT_GT(levelNum, 0);
1546 for (int j = 0; j < levelNum; j++) {
1547 EXPECT_GE(levels[j], 0);
1548 }
1549 }
1550 }
1551
1552 /**
1553 * @tc.number : VIDEO_MPEG4SWDEC_CAP_5400
1554 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
1555 * @tc.desc : api test
1556 */
1557 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_5400, TestSize.Level2)
1558 {
1559 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1560 false, SOFTWARE);
1561 ASSERT_NE(nullptr, capability);
1562 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1563 MPEG4_PROFILE_SIMPLE, ERROR_LEVEL));
1564 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1565 MPEG4_PROFILE_SIMPLE_SCALABLE, ERROR_LEVEL));
1566 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1567 MPEG4_PROFILE_CORE, ERROR_LEVEL));
1568 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1569 MPEG4_PROFILE_MAIN, ERROR_LEVEL));
1570 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1571 MPEG4_PROFILE_NBIT, ERROR_LEVEL));
1572 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1573 MPEG4_PROFILE_HYBRID, ERROR_LEVEL));
1574 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1575 MPEG4_PROFILE_BASIC_ANIMATED_TEXTURE, ERROR_LEVEL));
1576 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1577 MPEG4_PROFILE_SCALABLE_TEXTURE, ERROR_LEVEL));
1578 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1579 MPEG4_PROFILE_SIMPLE_FA, ERROR_LEVEL));
1580 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1581 MPEG4_PROFILE_ADVANCED_REAL_TIME_SIMPLE, ERROR_LEVEL));
1582 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1583 MPEG4_PROFILE_CORE_SCALABLE, ERROR_LEVEL));
1584 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1585 MPEG4_PROFILE_ADVANCED_CORE, ERROR_LEVEL));
1586 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1587 MPEG4_PROFILE_CORE_SCALABLE, ERROR_LEVEL));
1588 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1589 MPEG4_PROFILE_ADVANCED_SCALABLE_TEXTURE, ERROR_LEVEL));
1590 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1591 MPEG4_PROFILE_ADVANCED_SIMPLE, ERROR_LEVEL));
1592 }
1593
1594 /**
1595 * @tc.number : VIDEO_MPEG4SWDEC_CAP_5500
1596 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
1597 * @tc.desc : api test
1598 */
1599 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_5500, TestSize.Level2)
1600 {
1601 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1602 false, SOFTWARE);
1603 ASSERT_NE(nullptr, capability);
1604 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1605 MPEG4_PROFILE_SIMPLE, MPEG4_LEVEL_6));
1606 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1607 MPEG4_PROFILE_SIMPLE_SCALABLE, MPEG4_LEVEL_2));
1608 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1609 MPEG4_PROFILE_CORE, MPEG4_LEVEL_2));
1610 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1611 MPEG4_PROFILE_MAIN, MPEG4_LEVEL_4));
1612 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1613 MPEG4_PROFILE_NBIT, MPEG4_LEVEL_2));
1614 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1615 MPEG4_PROFILE_HYBRID, MPEG4_LEVEL_2));
1616 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1617 MPEG4_PROFILE_BASIC_ANIMATED_TEXTURE, MPEG4_LEVEL_2));
1618 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1619 MPEG4_PROFILE_SCALABLE_TEXTURE, MPEG4_LEVEL_1));
1620 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1621 MPEG4_PROFILE_SIMPLE_FA, MPEG4_LEVEL_2));
1622 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1623 MPEG4_PROFILE_ADVANCED_REAL_TIME_SIMPLE, MPEG4_LEVEL_4));
1624 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1625 MPEG4_PROFILE_CORE_SCALABLE, MPEG4_LEVEL_3));
1626 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1627 MPEG4_PROFILE_ADVANCED_CORE, MPEG4_LEVEL_2));
1628 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1629 MPEG4_PROFILE_CORE_SCALABLE, MPEG4_LEVEL_2));
1630 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1631 MPEG4_PROFILE_ADVANCED_SCALABLE_TEXTURE, MPEG4_LEVEL_3));
1632 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability,
1633 MPEG4_PROFILE_ADVANCED_SIMPLE, MPEG4_LEVEL_5));
1634 }
1635
1636 /**
1637 * @tc.number : VIDEO_MPEG4SWDEC_CAP_5600
1638 * @tc.name : OH_AVCapability_IsFeatureSupported param correct
1639 * @tc.desc : api test
1640 */
1641 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_5600, TestSize.Level2)
1642 {
1643 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1644 false, SOFTWARE);
1645 ASSERT_NE(nullptr, capability);
1646 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
1647 }
1648
1649 /**
1650 * @tc.number : VIDEO_MPEG4SWDEC_CAP_5700
1651 * @tc.name : OH_AVCapability_IsFeatureSupported param correct
1652 * @tc.desc : api test
1653 */
1654 HWTEST_F(Mpeg4SwdecApiNdkTest, VIDEO_MPEG4SWDEC_CAP_5700, TestSize.Level2)
1655 {
1656 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2,
1657 false, SOFTWARE);
1658 ASSERT_NE(nullptr, capability);
1659 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(capability, VIDEO_ENCODER_LONG_TERM_REFERENCE);
1660 ASSERT_EQ(nullptr, format);
1661 OH_AVFormat_Destroy(format);
1662 }
1663 } // namespace