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