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