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