1 /*
2 * Copyright (C) 2023 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 "codeclist_unit_test.h"
17 #include <fcntl.h>
18 #include <fstream>
19 #include <iostream>
20 #include <string>
21 #include <vector>
22 #include "gtest/gtest.h"
23
24 using namespace testing::ext;
25 using namespace OHOS::MediaAVCodec;
26 using namespace OHOS::MediaAVCodec::CodecListTestParam;
27
SetUpTestCase()28 void CodecListUnitTest::SetUpTestCase() {}
29
TearDownTestCase()30 void CodecListUnitTest::TearDownTestCase() {}
31
SetUp()32 void CodecListUnitTest::SetUp() {}
33
TearDown()34 void CodecListUnitTest::TearDown() {}
35
VectorToString(const std::vector<int32_t> list,const std::string listName)36 string VectorToString(const std::vector<int32_t> list, const std::string listName)
37 {
38 std::string ret = listName;
39 ret += "={";
40 for (auto it = list.begin(); it != list.end(); ++it) {
41 ret += std::to_string(*it) + ", ";
42 }
43 ret += "}";
44 return ret;
45 }
46
47 /**
48 * @tc.name: CodecList_GetCapabilityByCategory_001
49 * @tc.desc: CodecList GetCapabilityByCategory
50 * @tc.type: FUNC
51 */
52 HWTEST_F(CodecListUnitTest, CodecList_GetCapabilityByCategory_001, TestSize.Level1)
53 {
54 capability_ = CodecListMockFactory::GetCapability(DEFAULT_VIDEO_MIME, false);
55 if (capability_ != nullptr && capability_->IsHardware()) {
56 isHardIncluded_ = true;
57 }
58 AVCodecCategory category;
59 if (isHardIncluded_) {
60 category = AVCodecCategory::AVCODEC_HARDWARE;
61 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
62 EXPECT_NE(nullptr, capability_);
63
64 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, true, category);
65 EXPECT_NE(nullptr, capability_);
66 }
67 category = AVCodecCategory::AVCODEC_SOFTWARE;
68 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_AUDIO_MIME, false, category);
69 EXPECT_NE(nullptr, capability_);
70
71 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_AUDIO_MIME, true, category);
72 EXPECT_NE(nullptr, capability_);
73
74 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
75 EXPECT_NE(nullptr, capability_);
76 }
77
78 /**
79 * @tc.name: CodecList_GetCapability_001
80 * @tc.desc: CodecList GetCapability
81 * @tc.type: FUNC
82 */
83 HWTEST_F(CodecListUnitTest, CodecList_GetCapability_001, TestSize.Level1)
84 {
85 for (auto it = CAPABILITY_DECODER_NAME.begin(); it != CAPABILITY_DECODER_NAME.end(); ++it) {
86 std::string mime = it->first;
87 capability_ = CodecListMockFactory::GetCapability(mime, false);
88 EXPECT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
89 }
90 for (auto it = CAPABILITY_ENCODER_NAME.begin(); it != CAPABILITY_ENCODER_NAME.end(); ++it) {
91 std::string mime = it->first;
92 capability_ = CodecListMockFactory::GetCapability(mime, true);
93 EXPECT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
94 }
95 if (isHardIncluded_) {
96 for (auto it = CAPABILITY_DECODER_HARD_NAME.begin(); it != CAPABILITY_DECODER_HARD_NAME.end(); ++it) {
97 std::string mime = it->first;
98 capability_ = CodecListMockFactory::GetCapability(mime, false);
99 EXPECT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
100 }
101
102 for (auto it = CAPABILITY_ENCODER_HARD_NAME.begin(); it != CAPABILITY_ENCODER_HARD_NAME.end(); ++it) {
103 std::string mime = it->first;
104 capability_ = CodecListMockFactory::GetCapability(mime, true);
105 EXPECT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
106 }
107 }
108 }
109
110 /**
111 * @tc.name: CodecList_IsHardware_001
112 * @tc.desc: CodecList IsHardware
113 * @tc.type: FUNC
114 */
115 HWTEST_F(CodecListUnitTest, CodecList_IsHardware_001, TestSize.Level1)
116 {
117 // audio decoder
118 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
119 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_AUDIO_MIME, false, category);
120 ASSERT_NE(nullptr, capability_);
121 EXPECT_FALSE(capability_->IsHardware());
122
123 // audio encoder
124 category = AVCodecCategory::AVCODEC_SOFTWARE;
125 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_AUDIO_MIME, false, category);
126 ASSERT_NE(nullptr, capability_);
127 EXPECT_FALSE(capability_->IsHardware());
128
129 // video decoder
130 category = AVCodecCategory::AVCODEC_SOFTWARE;
131 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
132 ASSERT_NE(nullptr, capability_);
133 EXPECT_FALSE(capability_->IsHardware());
134
135 if (isHardIncluded_) {
136 category = AVCodecCategory::AVCODEC_HARDWARE;
137 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
138 EXPECT_NE(nullptr, capability_);
139 EXPECT_FALSE(capability_->IsHardware());
140 }
141 }
142
143 /**
144 * @tc.name: CodecList_GetName_001
145 * @tc.desc: CodecList GetName
146 * @tc.type: FUNC
147 */
148 HWTEST_F(CodecListUnitTest, CodecList_GetName_001, TestSize.Level1)
149 {
150 for (auto it = CAPABILITY_DECODER_NAME.begin(); it != CAPABILITY_DECODER_NAME.end(); ++it) {
151 std::string mime = it->first;
152 std::string nameOfMime = it->second;
153 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
154 capability_ = CodecListMockFactory::GetCapabilityByCategory(mime, false, category);
155 ASSERT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
156 std::string codecName = capability_->GetName();
157 EXPECT_EQ(nameOfMime, codecName) << mime << " get error name: " << codecName << std::endl;
158 std::cout << "codecName is out : " << codecName << std::endl;
159 // std::cout << "codecName addr is out : " << (void*)codecName << std::endl;
160 }
161 for (auto it = CAPABILITY_ENCODER_NAME.begin(); it != CAPABILITY_ENCODER_NAME.end(); ++it) {
162 std::string mime = it->first;
163 std::string nameOfMime = it->second;
164 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
165 capability_ = CodecListMockFactory::GetCapabilityByCategory(mime, true, category);
166 ASSERT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
167 std::string codecName = capability_->GetName();
168 if (mime == std::string(CodecMimeType::AUDIO_AAC)) {
169 bool check = (codecName == nameOfMime ||
170 codecName == std::string(AVCodecCodecName::AUDIO_ENCODER_VENDOR_AAC_NAME));
171 EXPECT_EQ(true, check) << mime << " get error name: " << codecName << std::endl;
172 } else {
173 EXPECT_EQ(nameOfMime, codecName) << mime << " get error name: " << codecName << std::endl;
174 }
175 }
176 if (isHardIncluded_) {
177 for (auto it = CAPABILITY_DECODER_HARD_NAME.begin(); it != CAPABILITY_DECODER_HARD_NAME.end(); ++it) {
178 std::string mime = it->first;
179 std::string nameOfMime = it->second;
180 capability_ = CodecListMockFactory::GetCapability(mime, false);
181 ASSERT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
182 std::string codecName = capability_->GetName();
183 EXPECT_EQ(nameOfMime, codecName) << mime << " get error name: " << codecName << std::endl;
184 }
185 for (auto it = CAPABILITY_ENCODER_HARD_NAME.begin(); it != CAPABILITY_ENCODER_HARD_NAME.end(); ++it) {
186 std::string mime = it->first;
187 std::string nameOfMime = it->second;
188 capability_ = CodecListMockFactory::GetCapability(mime, true);
189 ASSERT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
190 std::string codecName = capability_->GetName();
191 if (codecName != "") {
192 EXPECT_EQ(nameOfMime, codecName) << mime << " get error name: " << codecName << std::endl;
193 }
194 }
195 }
196 }
197
198 /**
199 * @tc.name: CodecList_GetMaxSupportedInstances_001
200 * @tc.desc: CodecList GetMaxSupportedInstances
201 * @tc.type: FUNC
202 */
203 HWTEST_F(CodecListUnitTest, CodecList_GetMaxSupportedInstances_001, TestSize.Level1)
204 {
205 // audio decoder
206 capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, false);
207 ASSERT_NE(nullptr, capability_) << "audio decoder codeclist create fail!" << std::endl;
208 EXPECT_EQ(MAX_SURPPORT_ACODEC, capability_->GetMaxSupportedInstances());
209
210 // audio encoder
211 capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, true);
212 ASSERT_NE(nullptr, capability_) << "audio encoder codeclist create fail!" << std::endl;
213 EXPECT_EQ(MAX_SURPPORT_ACODEC, capability_->GetMaxSupportedInstances());
214
215 // video decoder
216 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
217 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
218 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
219 EXPECT_EQ(MAX_SURPPORT_VCODEC, capability_->GetMaxSupportedInstances());
220 }
221
222 /**
223 * @tc.name: CodecList_GetEncoderBitrateRange_001
224 * @tc.desc: CodecList GetEncoderBitrateRange
225 * @tc.type: FUNC
226 */
227 HWTEST_F(CodecListUnitTest, CodecList_GetEncoderBitrateRange_001, TestSize.Level1)
228 {
229 // audio encoder
230 capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, true);
231 ASSERT_NE(nullptr, capability_) << "audio encoder codeclist create fail!" << std::endl;
232 Range bitrateRange = capability_->GetEncoderBitrateRange();
233 EXPECT_EQ(DEFAULT_BITRATE_RANGE.minVal, bitrateRange.minVal);
234 EXPECT_EQ(DEFAULT_BITRATE_RANGE.maxVal, bitrateRange.maxVal);
235 }
236
237 /**
238 * @tc.name: CodecList_IsEncoderBitrateModeSupported_001
239 * @tc.desc: CodecList IsEncoderBitrateModeSupported
240 * @tc.type: FUNC
241 */
242 HWTEST_F(CodecListUnitTest, CodecList_IsEncoderBitrateModeSupported_001, TestSize.Level1)
243 {
244 // audio encoder
245 capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, true);
246 ASSERT_NE(nullptr, capability_) << "audio encoder codeclist create fail!" << std::endl;
247
248 // positive case
249 OH_BitrateMode bitrateMode = OH_BitrateMode::BITRATE_MODE_CBR;
250 EXPECT_FALSE(capability_->IsEncoderBitrateModeSupported(bitrateMode));
251
252 // negative case
253 bitrateMode = OH_BitrateMode::BITRATE_MODE_VBR;
254 EXPECT_FALSE(capability_->IsEncoderBitrateModeSupported(bitrateMode));
255 }
256
257 /**
258 * @tc.name: CodecList_GetEncoderQualityRange_001
259 * @tc.desc: CodecList GetEncoderQualityRange
260 * @tc.type: FUNC
261 */
262 HWTEST_F(CodecListUnitTest, CodecList_GetEncoderQualityRange_001, TestSize.Level1)
263 {
264 // audio encoder
265 capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, true);
266 ASSERT_NE(nullptr, capability_) << "audio encoder codeclist create fail!" << std::endl;
267
268 Range qualityRange = capability_->GetEncoderQualityRange();
269 EXPECT_EQ(DEFAULT_QUALITY_RANGE.minVal, qualityRange.minVal);
270 EXPECT_EQ(DEFAULT_QUALITY_RANGE.maxVal, qualityRange.maxVal);
271 }
272
273 /**
274 * @tc.name: CodecList_GetEncoderComplexityRange_001
275 * @tc.desc: CodecList GetEncoderComplexityRange
276 * @tc.type: FUNC
277 */
278 HWTEST_F(CodecListUnitTest, CodecList_GetEncoderComplexityRange_001, TestSize.Level1)
279 {
280 // audio encoder
281 capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, true);
282 ASSERT_NE(nullptr, capability_) << "audio encoder codeclist create fail!" << std::endl;
283
284 Range complexityRange = capability_->GetEncoderComplexityRange();
285 EXPECT_EQ(DEFAULT_COMPLEXITY_RANGE.minVal, complexityRange.minVal);
286 EXPECT_EQ(DEFAULT_COMPLEXITY_RANGE.maxVal, complexityRange.maxVal);
287 }
288
289 /**
290 * @tc.name: CodecList_GetAudioSupportedSampleRates_001
291 * @tc.desc: CodecList GetAudioSupportedSampleRates
292 * @tc.type: FUNC
293 */
294 HWTEST_F(CodecListUnitTest, CodecList_GetAudioSupportedSampleRates_001, TestSize.Level1)
295 {
296 // audio encoder
297 capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, true);
298 ASSERT_NE(nullptr, capability_) << "audio encoder codeclist create fail!" << std::endl;
299 std::vector<int32_t> sampleRates = capability_->GetAudioSupportedSampleRates();
300 EXPECT_EQ(DEFAULT_AUDIO_ACC_SAMPLES, sampleRates);
301 }
302
303 /**
304 * @tc.name: CodecList_GetAudioChannelsRange_001
305 * @tc.desc: CodecList GetAudioChannelsRange
306 * @tc.type: FUNC
307 */
308 HWTEST_F(CodecListUnitTest, CodecList_GetAudioChannelsRange_001, TestSize.Level1)
309 {
310 // audio encoder
311 capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, true);
312 ASSERT_NE(nullptr, capability_) << "audio encoder codeclist create fail!" << std::endl;
313
314 Range channelCountRange = capability_->GetAudioChannelsRange();
315 EXPECT_EQ(DEFAULT_CHANNELCOUNT_RANGE.minVal, channelCountRange.minVal);
316 EXPECT_EQ(DEFAULT_CHANNELCOUNT_RANGE.maxVal, channelCountRange.maxVal);
317 }
318
319 /**
320 * @tc.name: CodecList_GetVideoWidthAlignment_001
321 * @tc.desc: CodecList GetVideoWidthAlignment
322 * @tc.type: FUNC
323 */
324 HWTEST_F(CodecListUnitTest, CodecList_GetVideoWidthAlignment_001, TestSize.Level1)
325 {
326 // video decoder
327 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
328 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
329 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
330
331 int32_t widthAlignment = capability_->GetVideoWidthAlignment();
332 EXPECT_EQ(DEFAULT_WIDTH_ALIGNMENT, widthAlignment);
333 }
334
335 /**
336 * @tc.name: CodecList_GetVideoHeightAlignment_001
337 * @tc.desc: CodecList GetVideoHeightAlignment
338 * @tc.type: FUNC
339 */
340 HWTEST_F(CodecListUnitTest, CodecList_GetVideoHeightAlignment_001, TestSize.Level1)
341 {
342 // video decoder
343 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
344 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
345 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
346
347 int32_t heightAlignment = capability_->GetVideoHeightAlignment();
348 EXPECT_EQ(DEFAULT_HEIGHT_ALIGNMENT, heightAlignment);
349 }
350
351 /**
352 * @tc.name: CodecList_GetVideoHeightRangeForWidth_001
353 * @tc.desc: CodecList GetVideoHeightRangeForWidth
354 * @tc.type: FUNC
355 */
356 HWTEST_F(CodecListUnitTest, CodecList_GetVideoHeightRangeForWidth_001, TestSize.Level1)
357 {
358 // video decoder
359 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
360 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
361 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
362
363 Range widthRange = capability_->GetVideoHeightRangeForWidth(DEFAULT_WIDTH);
364 EXPECT_EQ(DEFAULT_WIDTH_RANGE.minVal, widthRange.minVal);
365 EXPECT_EQ(DEFAULT_WIDTH_RANGE.maxVal, widthRange.maxVal);
366 }
367
368 /**
369 * @tc.name: CodecList_GetVideoWidthRangeForHeight_001
370 * @tc.desc: CodecList GetVideoWidthRangeForHeight
371 * @tc.type: FUNC
372 */
373 HWTEST_F(CodecListUnitTest, CodecList_GetVideoWidthRangeForHeight_001, TestSize.Level1)
374 {
375 // video decoder
376 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
377 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
378 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
379
380 Range heightRange = capability_->GetVideoWidthRangeForHeight(DEFAULT_HEIGHT);
381 EXPECT_EQ(DEFAULT_HEIGHT_RANGE_OF_WIDTH.minVal, heightRange.minVal);
382 EXPECT_EQ(DEFAULT_HEIGHT_RANGE_OF_WIDTH.maxVal, heightRange.maxVal);
383 }
384
385 /**
386 * @tc.name: CodecList_GetVideoWidthRange_001
387 * @tc.desc: CodecList GetVideoWidthRange
388 * @tc.type: FUNC
389 */
390 HWTEST_F(CodecListUnitTest, CodecList_GetVideoWidthRange_001, TestSize.Level1)
391 {
392 // video decoder
393 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
394 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
395 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
396
397 Range widthRange = capability_->GetVideoWidthRange();
398 EXPECT_EQ(DEFAULT_WIDTH_RANGE.minVal, widthRange.minVal);
399 EXPECT_EQ(DEFAULT_WIDTH_RANGE.maxVal, widthRange.maxVal);
400 }
401
402 /**
403 * @tc.name: CodecList_GetVideoHeightRange_001
404 * @tc.desc: CodecList GetVideoHeightRange
405 * @tc.type: FUNC
406 */
407 HWTEST_F(CodecListUnitTest, CodecList_GetVideoHeightRange_001, TestSize.Level1)
408 {
409 // video decoder
410 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
411 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
412 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
413
414 Range heightRange = capability_->GetVideoHeightRange();
415 EXPECT_EQ(DEFAULT_HEIGHT_RANGE.minVal, heightRange.minVal);
416 EXPECT_EQ(DEFAULT_HEIGHT_RANGE.maxVal, heightRange.maxVal);
417 }
418
419 /**
420 * @tc.name: CodecList_IsVideoSizeSupported_001
421 * @tc.desc: CodecList IsVideoSizeSupported
422 * @tc.type: FUNC
423 */
424 HWTEST_F(CodecListUnitTest, CodecList_IsVideoSizeSupported_001, TestSize.Level1)
425 {
426 // video decoder
427 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
428 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
429 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
430
431 int32_t wmin = DEFAULT_WIDTH_RANGE.minVal;
432 int32_t wmax = DEFAULT_WIDTH_RANGE.maxVal;
433 int32_t hmin = DEFAULT_HEIGHT_RANGE.minVal;
434 int32_t hmax = DEFAULT_HEIGHT_RANGE.maxVal;
435 // case 1 - 13, postive param
436 EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT))
437 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << std::endl;
438 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin, DEFAULT_HEIGHT))
439 << "width:" << wmin << "height:" << DEFAULT_HEIGHT << std::endl;
440 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin + 2, DEFAULT_HEIGHT))
441 << "width:" << wmin + 2 << "height:" << DEFAULT_HEIGHT << std::endl;
442 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin + 2, hmax))
443 << "width:" << wmin + 2 << "height:" << hmax << std::endl;
444 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin + 2, hmax - 2))
445 << "width:" << wmin + 2 << "height:" << hmax - 2 << std::endl;
446 EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH, hmax))
447 << "width:" << DEFAULT_WIDTH << "height:" << hmax << std::endl;
448 EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH, hmax - 2))
449 << "width:" << DEFAULT_WIDTH << "height:" << hmax - 2 << std::endl;
450 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax, DEFAULT_HEIGHT))
451 << "width:" << wmax << "height:" << DEFAULT_HEIGHT << std::endl;
452 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax - 2, DEFAULT_HEIGHT))
453 << "width:" << wmax - 2 << "height:" << DEFAULT_HEIGHT << std::endl;
454 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax - 2, hmin))
455 << "width:" << wmax - 2 << "height:" << DEFAULT_HEIGHT << std::endl;
456 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax - 2, hmin + 2))
457 << "width:" << wmax - 2 << "height:" << hmin + 2 << std::endl;
458 EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH, hmin))
459 << "width:" << DEFAULT_WIDTH << "height:" << hmin << std::endl;
460 EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH, hmin + 2))
461 << "width:" << DEFAULT_WIDTH << "height:" << hmin + 2 << std::endl;
462 }
463
464 /**
465 * @tc.name: CodecList_IsVideoSizeSupported_002
466 * @tc.desc: CodecList IsVideoSizeSupported
467 * @tc.type: FUNC
468 */
469 HWTEST_F(CodecListUnitTest, CodecList_IsVideoSizeSupported_002, TestSize.Level1)
470 {
471 // video decoder
472 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
473 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
474 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
475
476 int32_t wmin = DEFAULT_WIDTH_RANGE.minVal;
477 int32_t wmax = DEFAULT_WIDTH_RANGE.maxVal;
478 int32_t hmin = DEFAULT_HEIGHT_RANGE.minVal;
479 int32_t hmax = DEFAULT_HEIGHT_RANGE.maxVal;
480 // case 1 - 10, negative param
481 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax + 2, hmin))
482 << "width:" << wmin + 2 << "height:" << hmin << std::endl;
483 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin - 2, hmin))
484 << "width:" << wmin - 2 << "height:" << hmin << std::endl;
485 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax + 2, hmax))
486 << "width:" << wmin + 2 << "height:" << hmax << std::endl;
487 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin - 2, hmax))
488 << "width:" << wmin - 2 << "height:" << hmax << std::endl;
489
490 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin, hmin - 2))
491 << "width:" << wmin << "height:" << hmin - 2 << std::endl;
492 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin, hmax + 2))
493 << "width:" << wmin << "height:" << hmax + 2 << std::endl;
494 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax, hmin - 2))
495 << "width:" << wmax << "height:" << hmin - 2 << std::endl;
496 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax, hmax + 2))
497 << "width:" << wmax << "height:" << hmax + 2 << std::endl;
498
499 EXPECT_FALSE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH + 1, DEFAULT_HEIGHT))
500 << "width:" << DEFAULT_WIDTH + 1 << "height:" << DEFAULT_HEIGHT << std::endl;
501 EXPECT_FALSE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT + 1))
502 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT + 1 << std::endl;
503 }
504
505 /**
506 * @tc.name: CodecList_GetVideoFrameRateRange_001
507 * @tc.desc: CodecList GetVideoFrameRateRange
508 * @tc.type: FUNC
509 */
510 HWTEST_F(CodecListUnitTest, CodecList_GetVideoFrameRateRange_001, TestSize.Level1)
511 {
512 // video decoder
513 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
514 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
515 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
516
517 Range framerateRange = capability_->GetVideoFrameRateRange();
518 EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.minVal, framerateRange.minVal);
519 EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.maxVal, framerateRange.maxVal);
520 }
521
522 /**
523 * @tc.name: CodecList_AreVideoSizeAndFrameRateSupported_001
524 * @tc.desc: CodecList AreVideoSizeAndFrameRateSupported
525 * @tc.type: FUNC
526 */
527 HWTEST_F(CodecListUnitTest, CodecList_AreVideoSizeAndFrameRateSupported_001, TestSize.Level1)
528 {
529 // video decoder
530 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
531 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
532 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
533 int32_t minVal = DEFAULT_FRAMERATE_RANGE.minVal;
534 int32_t maxVal = DEFAULT_FRAMERATE_RANGE.maxVal;
535 // case 1 - 4, positive param
536 EXPECT_TRUE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FRAMERATE))
537 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << DEFAULT_FRAMERATE << std::endl;
538 EXPECT_TRUE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, minVal + 1))
539 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << minVal + 1 << std::endl;
540 EXPECT_TRUE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, maxVal))
541 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << maxVal << std::endl;
542 EXPECT_TRUE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, maxVal - 1))
543 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << maxVal - 1 << std::endl;
544 }
545
546 /**
547 * @tc.name: CodecList_AreVideoSizeAndFrameRateSupported_002
548 * @tc.desc: CodecList AreVideoSizeAndFrameRateSupported
549 * @tc.type: FUNC
550 */
551 HWTEST_F(CodecListUnitTest, CodecList_AreVideoSizeAndFrameRateSupported_002, TestSize.Level1)
552 {
553 // video decoder
554 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
555 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
556 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
557 int32_t minVal = DEFAULT_FRAMERATE_RANGE.minVal;
558 int32_t maxVal = DEFAULT_FRAMERATE_RANGE.maxVal;
559 // case 1 - 9, negative param
560 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, minVal - 1))
561 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << minVal - 1 << std::endl;
562 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, maxVal + 1))
563 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << minVal + 1 << std::endl;
564 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, ERROR_FRAMERATE))
565 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << ERROR_FRAMERATE << std::endl;
566 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, ERROR_HEIGHT, DEFAULT_FRAMERATE))
567 << "width:" << DEFAULT_WIDTH << "height:" << ERROR_HEIGHT << "framerate: " << DEFAULT_FRAMERATE << std::endl;
568 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, ERROR_HEIGHT, ERROR_FRAMERATE))
569 << "width:" << DEFAULT_WIDTH << "height:" << ERROR_HEIGHT << "framerate: " << ERROR_FRAMERATE << std::endl;
570 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, DEFAULT_HEIGHT, DEFAULT_FRAMERATE))
571 << "width:" << ERROR_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << DEFAULT_FRAMERATE << std::endl;
572 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, DEFAULT_HEIGHT, ERROR_FRAMERATE))
573 << "width:" << ERROR_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << ERROR_FRAMERATE << std::endl;
574 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, ERROR_HEIGHT, DEFAULT_FRAMERATE))
575 << "width:" << ERROR_WIDTH << "height:" << ERROR_HEIGHT << "framerate: " << DEFAULT_FRAMERATE << std::endl;
576 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, ERROR_HEIGHT, ERROR_FRAMERATE))
577 << "width:" << ERROR_WIDTH << "height:" << ERROR_HEIGHT << "framerate: " << ERROR_FRAMERATE << std::endl;
578 }
579
580 /**
581 * @tc.name: CodecList_GetVideoFrameRateRangeForSize_001
582 * @tc.desc: CodecList GetVideoFrameRateRangeForSize
583 * @tc.type: FUNC
584 */
585 HWTEST_F(CodecListUnitTest, CodecList_GetVideoFrameRateRangeForSize_001, TestSize.Level1)
586 {
587 // video decoder
588 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
589 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
590 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
591
592 int32_t wmax = DEFAULT_HEIGHT_RANGE_OF_WIDTH.maxVal;
593 int32_t hmax = DEFAULT_WIDTH_RANGE_OF_HEIGHT.maxVal;
594 Range framerateRange = capability_->GetVideoFrameRateRangeForSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
595 EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.minVal, framerateRange.minVal);
596 EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.maxVal, framerateRange.maxVal);
597
598 framerateRange = capability_->GetVideoFrameRateRangeForSize(wmax, hmax);
599 EXPECT_EQ(0, framerateRange.minVal);
600 EXPECT_EQ(26, framerateRange.maxVal); // 26: The return values after (2304, 4096) are passed in
601 }
602
603 /**
604 * @tc.name: CodecList_GetVideoFrameRateRangeForSize_002
605 * @tc.desc: CodecList GetVideoFrameRateRangeForSize
606 * @tc.type: FUNC
607 */
608 HWTEST_F(CodecListUnitTest, CodecList_GetVideoFrameRateRangeForSize_002, TestSize.Level1)
609 {
610 // video decoder
611 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
612 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
613 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
614
615 int32_t wmax = DEFAULT_WIDTH_RANGE.maxVal;
616 int32_t hmax = DEFAULT_HEIGHT_RANGE.maxVal;
617 Range framerateRange = capability_->GetVideoFrameRateRangeForSize(0, 0);
618 EXPECT_EQ(0, framerateRange.minVal);
619 EXPECT_EQ(0, framerateRange.maxVal);
620
621 framerateRange = capability_->GetVideoFrameRateRangeForSize(wmax + 2, hmax + 2);
622 EXPECT_EQ(0, framerateRange.minVal);
623 EXPECT_EQ(0, framerateRange.maxVal);
624
625 framerateRange = capability_->GetVideoFrameRateRangeForSize(wmax - 1, hmax - 1);
626 EXPECT_EQ(0, framerateRange.minVal);
627 EXPECT_EQ(0, framerateRange.maxVal);
628
629 framerateRange = capability_->GetVideoFrameRateRangeForSize(-2, -2);
630 EXPECT_EQ(0, framerateRange.minVal);
631 EXPECT_EQ(0, framerateRange.maxVal);
632 }
633
634 /**
635 * @tc.name: CodecList_GetVideoSupportedPixelFormats_001
636 * @tc.desc: CodecList GetVideoSupportedPixelFormats
637 * @tc.type: FUNC
638 */
639 HWTEST_F(CodecListUnitTest, CodecList_GetVideoSupportedPixelFormats_001, TestSize.Level1)
640 {
641 // video decoder
642 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
643 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
644 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
645
646 std::vector<int32_t> pixFormats = capability_->GetVideoSupportedPixelFormats();
647 EXPECT_EQ(DEFAULT_VIDEO_AVC_PIXFORMATS, pixFormats);
648 }
649
650 /**
651 * @tc.name: CodecList_GetSupportedProfiles_001
652 * @tc.desc: CodecList GetSupportedProfiles
653 * @tc.type: FUNC
654 */
655 HWTEST_F(CodecListUnitTest, CodecList_GetSupportedProfiles_001, TestSize.Level1)
656 {
657 // video decoder
658 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
659 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
660 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
661
662 std::vector<int32_t> profiles = capability_->GetSupportedProfiles();
663 EXPECT_EQ(DEFAULT_VIDEO_AVC_PROFILES, profiles);
664 }
665
666 /**
667 * @tc.name: CodecList_GetSupportedLevelsForProfile_001
668 * @tc.desc: CodecList GetSupportedLevelsForProfile
669 * @tc.type: FUNC
670 */
671 HWTEST_F(CodecListUnitTest, CodecList_GetSupportedLevelsForProfile_001, TestSize.Level1)
672 {
673 // video decoder
674 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
675 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
676 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
677
678 std::vector<int32_t> levels = capability_->GetSupportedLevelsForProfile(DEFAULT_VIDEO_AVC_PROFILE);
679 EXPECT_EQ(DEFAULT_VIDEO_AVC_LEVELS, levels);
680 }
681
682 /**
683 * @tc.name: CodecList_AreProfileAndLevelSupported_001
684 * @tc.desc: CodecList AreProfileAndLevelSupported
685 * @tc.type: FUNC
686 */
687 HWTEST_F(CodecListUnitTest, CodecList_AreProfileAndLevelSupported_001, TestSize.Level1)
688 {
689 // video decoder
690 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
691 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
692 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
693 // case 1 - 16, postive param
694 for (auto it : DEFAULT_VIDEO_AVC_LEVELS) {
695 EXPECT_TRUE(capability_->AreProfileAndLevelSupported(DEFAULT_VIDEO_AVC_PROFILE, it));
696 }
697 }
698
699 /**
700 * @tc.name: CodecList_AreProfileAndLevelSupported_002
701 * @tc.desc: CodecList AreProfileAndLevelSupported
702 * @tc.type: FUNC
703 */
704 HWTEST_F(CodecListUnitTest, CodecList_AreProfileAndLevelSupported_002, TestSize.Level1)
705 {
706 // video decoder
707 AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
708 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
709 ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
710 // case 1, negative param
711 EXPECT_FALSE(capability_->AreProfileAndLevelSupported(DEFAULT_VIDEO_AVC_PROFILE, ERROR_LEVEL));
712 // case 2, negative param
713 EXPECT_FALSE(capability_->AreProfileAndLevelSupported(ERROR_VIDEO_AVC_PROFILE, DEFAULT_LEVEL));
714 // case 3, negative param
715 EXPECT_FALSE(capability_->AreProfileAndLevelSupported(ERROR_VIDEO_AVC_PROFILE, ERROR_LEVEL));
716 }
717
718 /**
719 * @tc.name: CodecList_UNSUPPORTED_MIME_001
720 * @tc.desc: CodecList use unsupprted mime
721 * @tc.type: FUNC
722 */
723 HWTEST_F(CodecListUnitTest, CodecList_UNSUPPORTED_MIME_001, TestSize.Level1)
724 {
725 capability_ = CodecListMockFactory::GetCapabilityByCategory(
726 DEFAULT_UNSUPPORTED_MIME, false, ::AVCodecCategory::AVCODEC_NONE);
727 if (capability_ != nullptr) {
728 EXPECT_EQ(capability_->GetName(), "");
729 EXPECT_EQ(capability_->IsHardware(), false);
730 EXPECT_EQ(capability_->IsEncoderBitrateModeSupported(OH_BitrateMode::BITRATE_MODE_CBR), false);
731 EXPECT_EQ(capability_->IsVideoSizeSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT), false);
732 EXPECT_EQ(capability_->AreVideoSizeAndFrameRateSupported(
733 DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FRAMERATE), false);
734 EXPECT_EQ(capability_->AreProfileAndLevelSupported(DEFAULT_VIDEO_AVC_PROFILE, DEFAULT_LEVEL), false);
735 EXPECT_EQ(capability_->GetMaxSupportedInstances(), 0);
736 EXPECT_EQ(capability_->GetVideoWidthAlignment(), 1);
737 EXPECT_EQ(capability_->GetVideoHeightAlignment(), 1);
738 std::vector<int32_t> sampleRates = capability_->GetAudioSupportedSampleRates();
739 EXPECT_EQ(sampleRates.size(), 0);
740 std::vector<int32_t> profiles = capability_->GetSupportedProfiles();
741 EXPECT_EQ(profiles.size(), 0);
742 std::vector<int32_t> pixFormats = capability_->GetVideoSupportedPixelFormats();
743 EXPECT_EQ(pixFormats.size(), 0);
744 std::vector<int32_t> levels = capability_->GetSupportedLevelsForProfile(DEFAULT_VIDEO_AVC_PROFILE);
745 EXPECT_EQ(levels.size(), 0);
746 }
747 }
748
749 /**
750 * @tc.name: CodecList_UNSUPPORTED_MIME_002
751 * @tc.desc: CodecList use unsupprted mime
752 * @tc.type: FUNC
753 */
754 HWTEST_F(CodecListUnitTest, CodecList_UNSUPPORTED_MIME_002, TestSize.Level1)
755 {
756 capability_ = CodecListMockFactory::GetCapabilityByCategory(
757 DEFAULT_UNSUPPORTED_MIME, false, AVCodecCategory::AVCODEC_SOFTWARE);
758 if (capability_ != nullptr) {
759 Range range = capability_->GetEncoderBitrateRange();
760 EXPECT_EQ(0, range.minVal);
761 EXPECT_EQ(0, range.maxVal);
762 range = capability_->GetEncoderQualityRange();
763 EXPECT_EQ(0, range.minVal);
764 EXPECT_EQ(0, range.maxVal);
765 range = capability_->GetEncoderComplexityRange();
766 EXPECT_EQ(0, range.minVal);
767 EXPECT_EQ(0, range.maxVal);
768 range = capability_->GetAudioChannelsRange();
769 EXPECT_EQ(0, range.minVal);
770 EXPECT_EQ(0, range.maxVal);
771 range = capability_->GetVideoWidthRangeForHeight(DEFAULT_HEIGHT);
772 EXPECT_EQ(0, range.minVal);
773 EXPECT_EQ(0, range.maxVal);
774 range = capability_->GetVideoHeightRangeForWidth(DEFAULT_WIDTH);
775 EXPECT_EQ(0, range.minVal);
776 EXPECT_EQ(0, range.maxVal);
777 range = capability_->GetVideoWidthRange();
778 EXPECT_EQ(0, range.minVal);
779 EXPECT_EQ(0, range.maxVal);
780 range = capability_->GetVideoHeightRange();
781 EXPECT_EQ(0, range.minVal);
782 EXPECT_EQ(0, range.maxVal);
783 range = capability_->GetVideoFrameRateRange();
784 EXPECT_EQ(0, range.minVal);
785 EXPECT_EQ(0, range.maxVal);
786 range = capability_->GetVideoFrameRateRangeForSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
787 EXPECT_EQ(0, range.minVal);
788 EXPECT_EQ(0, range.maxVal);
789 std::vector<Range> ranges = capability_->GetAudioSupportedSampleRateRanges();
790 EXPECT_EQ(0, ranges[0].minVal);
791 EXPECT_EQ(0, ranges[0].maxVal);
792 }
793 }
794
795 /**
796 * @tc.name: CodecList_GetCapabilityByCategory_Vvc_001
797 * @tc.desc: CodecList GetCapabilityByCategory Vvc
798 * @tc.type: FUNC
799 */
800 HWTEST_F(CodecListUnitTest, CodecList_GetCapabilityByCategory_Vvc_001, TestSize.Level1)
801 {
802 if (!access("/system/lib64/media/", 0)) {
803 capability_ = CodecListMockFactory::GetCapability(DEFAULT_VIDEO_VVC_MIME, false);
804 if (capability_ != nullptr && capability_->IsHardware()) {
805 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
806 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
807 EXPECT_NE(nullptr, capability_);
808 }
809 }
810 }
811
812 /**
813 * @tc.name: CodecList_IsHardware_Vvc_001
814 * @tc.desc: CodecList IsHardware Vvc
815 * @tc.type: FUNC
816 */
817 HWTEST_F(CodecListUnitTest, CodecList_IsHardware_Vvc_001, TestSize.Level1)
818 {
819 if (!access("/system/lib64/media/", 0)) {
820 // video decoder
821 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
822 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
823 if (capability_ != nullptr) {
824 EXPECT_TRUE(capability_->IsHardware());
825 }
826 }
827 }
828
829 /**
830 * @tc.name: CodecList_GetName_Vvc_001
831 * @tc.desc: CodecList GetName Vvc
832 * @tc.type: FUNC
833 */
834 HWTEST_F(CodecListUnitTest, CodecList_GetName_Vvc_001, TestSize.Level1)
835 {
836 if (!access("/system/lib64/media/", 0)) {
837 for (auto it = CAPABILITY_DECODER_HARD_NAME_VVC.begin(); it != CAPABILITY_DECODER_HARD_NAME_VVC.end(); ++it) {
838 std::string mime = it->first;
839 std::string nameOfMime = it->second;
840 capability_ = CodecListMockFactory::GetCapability(mime, false);
841 if (capability_ != nullptr) {
842 std::string codecName = capability_->GetName();
843 EXPECT_EQ(nameOfMime, codecName) << mime << " get error name: " << codecName << std::endl;
844 }
845 }
846 }
847 }
848
849 /**
850 * @tc.name: CodecList_GetMaxSupportedInstances_Vvc_001
851 * @tc.desc: CodecList GetMaxSupportedInstances Vvc
852 * @tc.type: FUNC
853 */
854 HWTEST_F(CodecListUnitTest, CodecList_GetMaxSupportedInstances_Vvc_001, TestSize.Level1)
855 {
856 if (!access("/system/lib64/media/", 0)) {
857 // video decoder
858 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
859 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
860 if (capability_ != nullptr) {
861 EXPECT_EQ(MAX_SURPPORT_VCODEC_VVC, capability_->GetMaxSupportedInstances());
862 }
863 }
864 }
865
866 /**
867 * @tc.name: CodecList_GetVideoWidthAlignment_Vvc_001
868 * @tc.desc: CodecList GetVideoWidthAlignment Vvc
869 * @tc.type: FUNC
870 */
871 HWTEST_F(CodecListUnitTest, CodecList_GetVideoWidthAlignment_Vvc_001, TestSize.Level1)
872 {
873 if (!access("/system/lib64/media/", 0)) {
874 // video decoder
875 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
876 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
877 if (capability_ != nullptr) {
878 int32_t widthAlignment = capability_->GetVideoWidthAlignment();
879 EXPECT_EQ(DEFAULT_WIDTH_ALIGNMENT, widthAlignment);
880 }
881 }
882 }
883
884 /**
885 * @tc.name: CodecList_GetVideoHeightAlignment_Vvc_001
886 * @tc.desc: CodecList GetVideoHeightAlignment Vvc
887 * @tc.type: FUNC
888 */
889 HWTEST_F(CodecListUnitTest, CodecList_GetVideoHeightAlignment_Vvc_001, TestSize.Level1)
890 {
891 if (!access("/system/lib64/media/", 0)) {
892 // video decoder
893 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
894 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
895 if (capability_ != nullptr) {
896 int32_t heightAlignment = capability_->GetVideoHeightAlignment();
897 EXPECT_EQ(DEFAULT_HEIGHT_ALIGNMENT, heightAlignment);
898 }
899 }
900 }
901
902 /**
903 * @tc.name: CodecList_GetVideoHeightRangeForWidth_Vvc_001
904 * @tc.desc: CodecList GetVideoHeightRangeForWidth Vvc
905 * @tc.type: FUNC
906 */
907 HWTEST_F(CodecListUnitTest, CodecList_GetVideoHeightRangeForWidth_Vvc_001, TestSize.Level1)
908 {
909 if (!access("/system/lib64/media/", 0)) {
910 // video decoder
911 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
912 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
913 if (capability_ != nullptr) {
914 Range widthRange = capability_->GetVideoHeightRangeForWidth(DEFAULT_WIDTH_VVC);
915 EXPECT_EQ(DEFAULT_HEIGHT_RANGE_OF_WIDTH_VVC.minVal, widthRange.minVal);
916 EXPECT_EQ(DEFAULT_HEIGHT_RANGE_OF_WIDTH_VVC.maxVal, widthRange.maxVal);
917 }
918 }
919 }
920
921 /**
922 * @tc.name: CodecList_GetVideoWidthRangeForHeight_Vvc_001
923 * @tc.desc: CodecList GetVideoWidthRangeForHeight Vvc
924 * @tc.type: FUNC
925 */
926 HWTEST_F(CodecListUnitTest, CodecList_GetVideoWidthRangeForHeight_Vvc_001, TestSize.Level1)
927 {
928 if (!access("/system/lib64/media/", 0)) {
929 // video decoder
930 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
931 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
932 if (capability_ != nullptr) {
933 Range heightRange = capability_->GetVideoWidthRangeForHeight(DEFAULT_HEIGHT_VVC);
934 EXPECT_EQ(DEFAULT_WIDTH_RANGE_OF_HEIGHT_VVC.minVal, heightRange.minVal);
935 EXPECT_EQ(DEFAULT_WIDTH_RANGE_OF_HEIGHT_VVC.maxVal, heightRange.maxVal);
936 }
937 }
938 }
939
940 /**
941 * @tc.name: CodecList_GetVideoWidthRange_Vvc_001
942 * @tc.desc: CodecList GetVideoWidthRange Vvc
943 * @tc.type: FUNC
944 */
945 HWTEST_F(CodecListUnitTest, CodecList_GetVideoWidthRange_Vvc_001, TestSize.Level1)
946 {
947 if (!access("/system/lib64/media/", 0)) {
948 // video decoder
949 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
950 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
951 if (capability_ != nullptr) {
952 Range widthRange = capability_->GetVideoWidthRange();
953 EXPECT_EQ(DEFAULT_WIDTH_RANGE_VVC.minVal, widthRange.minVal);
954 EXPECT_EQ(DEFAULT_WIDTH_RANGE_VVC.maxVal, widthRange.maxVal);
955 }
956 }
957 }
958
959 /**
960 * @tc.name: CodecList_GetVideoHeightRange_Vvc_001
961 * @tc.desc: CodecList GetVideoHeightRange Vvc
962 * @tc.type: FUNC
963 */
964 HWTEST_F(CodecListUnitTest, CodecList_GetVideoHeightRange_Vvc_001, TestSize.Level1)
965 {
966 if (!access("/system/lib64/media/", 0)) {
967 // video decoder
968 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
969 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
970 if (capability_ != nullptr) {
971 Range heightRange = capability_->GetVideoHeightRange();
972 EXPECT_EQ(DEFAULT_HEIGHT_RANGE_VVC.minVal, heightRange.minVal);
973 EXPECT_EQ(DEFAULT_HEIGHT_RANGE_VVC.maxVal, heightRange.maxVal);
974 }
975 }
976 }
977
978 /**
979 * @tc.name: CodecList_IsVideoSizeSupported_Vvc_001
980 * @tc.desc: CodecList IsVideoSizeSupported Vvc
981 * @tc.type: FUNC
982 */
983 HWTEST_F(CodecListUnitTest, CodecList_IsVideoSizeSupported_Vvc_001, TestSize.Level1)
984 {
985 if (!access("/system/lib64/media/", 0)) {
986 // video decoder
987 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
988 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
989 if (capability_ != nullptr) {
990 int32_t wmin = DEFAULT_WIDTH_RANGE_VVC.minVal;
991 int32_t wmax = DEFAULT_WIDTH_RANGE_VVC.maxVal;
992 int32_t hmin = DEFAULT_HEIGHT_RANGE_VVC.minVal;
993 int32_t hmax = DEFAULT_HEIGHT_RANGE_VVC.maxVal;
994 // case 1 - 13, postive param
995 EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH_VVC, DEFAULT_HEIGHT_VVC))
996 << "width:" << DEFAULT_WIDTH_VVC << "height:" << DEFAULT_HEIGHT_VVC << std::endl;
997 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin, DEFAULT_HEIGHT_VVC))
998 << "width:" << wmin << "height:" << DEFAULT_HEIGHT_VVC << std::endl;
999 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin + 2, DEFAULT_HEIGHT_VVC))
1000 << "width:" << wmin + 2 << "height:" << DEFAULT_HEIGHT_VVC << std::endl;
1001 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin + 2, hmax))
1002 << "width:" << wmin + 2 << "height:" << hmax << std::endl;
1003 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin + 2, hmax - 2))
1004 << "width:" << wmin + 2 << "height:" << hmax - 2 << std::endl;
1005 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax, DEFAULT_HEIGHT_VVC))
1006 << "width:" << wmax << "height:" << DEFAULT_HEIGHT_VVC << std::endl;
1007 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax - 2, DEFAULT_HEIGHT_VVC))
1008 << "width:" << wmax - 2 << "height:" << DEFAULT_HEIGHT_VVC << std::endl;
1009 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax - 2, hmin))
1010 << "width:" << wmax - 2 << "height:" << hmin << std::endl;
1011 EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax - 2, hmin + 2))
1012 << "width:" << wmax - 2 << "height:" << hmin + 2 << std::endl;
1013 EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH_VVC, hmin))
1014 << "width:" << DEFAULT_WIDTH_VVC << "height:" << hmin << std::endl;
1015 EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH_VVC, hmin + 2))
1016 << "width:" << DEFAULT_WIDTH_VVC << "height:" << hmin + 2 << std::endl;
1017 // Swap case
1018 EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_HEIGHT_VVC, hmax))
1019 << "width:" << DEFAULT_HEIGHT_VVC << "height:" << hmax << std::endl;
1020 EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_HEIGHT_VVC, hmax - 2))
1021 << "width:" << DEFAULT_HEIGHT_VVC << "height:" << hmax - 2 << std::endl;
1022 }
1023 }
1024 }
1025
1026 /**
1027 * @tc.name: CodecList_IsVideoSizeSupported_Vvc_002
1028 * @tc.desc: CodecList IsVideoSizeSupported Vvc
1029 * @tc.type: FUNC
1030 */
1031 HWTEST_F(CodecListUnitTest, CodecList_IsVideoSizeSupported_Vvc_002, TestSize.Level1)
1032 {
1033 if (!access("/system/lib64/media/", 0)) {
1034 // video decoder
1035 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1036 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1037 if (capability_ != nullptr) {
1038 int32_t wmin = DEFAULT_WIDTH_RANGE_VVC.minVal;
1039 int32_t wmax = DEFAULT_WIDTH_RANGE_VVC.maxVal;
1040 int32_t hmin = DEFAULT_HEIGHT_RANGE_VVC.minVal;
1041 int32_t hmax = DEFAULT_HEIGHT_RANGE_VVC.maxVal;
1042 // case 1 - 10, negative param
1043 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax + 2, hmin))
1044 << "width:" << wmax + 2 << "height:" << hmin << std::endl;
1045 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin - 2, hmin))
1046 << "width:" << wmin - 2 << "height:" << hmin << std::endl;
1047 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax + 2, hmax))
1048 << "width:" << wmax + 2 << "height:" << hmax << std::endl;
1049 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin - 2, hmax))
1050 << "width:" << wmin - 2 << "height:" << hmax << std::endl;
1051
1052 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin, hmin - 2))
1053 << "width:" << wmin << "height:" << hmin - 2 << std::endl;
1054 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin, hmax + 2))
1055 << "width:" << wmin << "height:" << hmax + 2 << std::endl;
1056 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax, hmin - 2))
1057 << "width:" << wmax << "height:" << hmin - 2 << std::endl;
1058 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax, hmax + 2))
1059 << "width:" << wmax << "height:" << hmax + 2 << std::endl;
1060
1061 EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax + 1, DEFAULT_HEIGHT_VVC))
1062 << "width:" << wmax + 1 << "height:" << DEFAULT_HEIGHT_VVC << std::endl;
1063 // Swap case
1064 EXPECT_FALSE(capability_->IsVideoSizeSupported(DEFAULT_HEIGHT_VVC, hmax + 1))
1065 << "width:" << DEFAULT_HEIGHT_VVC << "height:" << hmax + 1 << std::endl;
1066 }
1067 }
1068 }
1069
1070 /**
1071 * @tc.name: CodecList_GetVideoFrameRateRange_Vvc_001
1072 * @tc.desc: CodecList GetVideoFrameRateRange Vvc
1073 * @tc.type: FUNC
1074 */
1075 HWTEST_F(CodecListUnitTest, CodecList_GetVideoFrameRateRange_Vvc_001, TestSize.Level1)
1076 {
1077 if (!access("/system/lib64/media/", 0)) {
1078 // video decoder
1079 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1080 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1081 if (capability_ != nullptr) {
1082 Range framerateRange = capability_->GetVideoFrameRateRange();
1083 EXPECT_EQ(DEFAULT_FRAMERATE_RANGE_VVC.minVal, framerateRange.minVal);
1084 EXPECT_EQ(DEFAULT_FRAMERATE_RANGE_VVC.maxVal, framerateRange.maxVal);
1085 }
1086 }
1087 }
1088
1089 /**
1090 * @tc.name: CodecList_AreVideoSizeAndFrameRateSupported_Vvc_001
1091 * @tc.desc: CodecList AreVideoSizeAndFrameRateSupported Vvc
1092 * @tc.type: FUNC
1093 */
1094 HWTEST_F(CodecListUnitTest, CodecList_AreVideoSizeAndFrameRateSupported_Vvc_001, TestSize.Level1)
1095 {
1096 if (!access("/system/lib64/media/", 0)) {
1097 // video decoder
1098 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1099 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1100 if (capability_ != nullptr) {
1101 int32_t minVal = DEFAULT_FRAMERATE_RANGE_VVC.minVal;
1102 int32_t maxVal = DEFAULT_FRAMERATE_RANGE_VVC.maxVal;
1103 // case 1 - 3, positive param
1104 EXPECT_TRUE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, minVal + 1))
1105 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << minVal + 1 << std::endl;
1106 EXPECT_TRUE(capability_->AreVideoSizeAndFrameRateSupported(128, 128, maxVal))
1107 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << maxVal << std::endl;
1108 EXPECT_TRUE(capability_->AreVideoSizeAndFrameRateSupported(128, 128, maxVal - 1))
1109 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << maxVal - 1 << std::endl;
1110 }
1111 }
1112 }
1113
1114 /**
1115 * @tc.name: CodecList_AreVideoSizeAndFrameRateSupported_Vvc_002
1116 * @tc.desc: CodecList AreVideoSizeAndFrameRateSupported Vvc
1117 * @tc.type: FUNC
1118 */
1119 HWTEST_F(CodecListUnitTest, CodecList_AreVideoSizeAndFrameRateSupported_Vvc_002, TestSize.Level1)
1120 {
1121 if (!access("/system/lib64/media/", 0)) {
1122 // video decoder
1123 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1124 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1125 if (capability_ != nullptr) {
1126 int32_t minVal = DEFAULT_FRAMERATE_RANGE_VVC.minVal;
1127 int32_t maxVal = DEFAULT_FRAMERATE_RANGE_VVC.maxVal;
1128 // case 1 - 10, negative param
1129 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, minVal))
1130 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << minVal << std::endl;
1131 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, minVal - 1))
1132 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << minVal - 1 << std::endl;
1133 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, maxVal + 1))
1134 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << maxVal + 1 << std::endl;
1135 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, ERROR_FRAMERATE))
1136 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate:" << ERROR_FRAMERATE
1137 << std::endl;
1138 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, ERROR_HEIGHT, DEFAULT_FRAMERATE))
1139 << "width:" << DEFAULT_WIDTH << "height:" << ERROR_HEIGHT << "framerate:" << DEFAULT_FRAMERATE
1140 << std::endl;
1141 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, ERROR_HEIGHT, ERROR_FRAMERATE))
1142 << "width:" << DEFAULT_WIDTH << "height:" << ERROR_HEIGHT << "framerate: " << ERROR_FRAMERATE
1143 << std::endl;
1144 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, DEFAULT_HEIGHT, DEFAULT_FRAMERATE))
1145 << "width:" << ERROR_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate:" << DEFAULT_FRAMERATE
1146 << std::endl;
1147 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, DEFAULT_HEIGHT, ERROR_FRAMERATE))
1148 << "width:" << ERROR_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << ERROR_FRAMERATE
1149 << std::endl;
1150 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, ERROR_HEIGHT, DEFAULT_FRAMERATE))
1151 << "width:" << ERROR_WIDTH << "height:" << ERROR_HEIGHT << "framerate: " << DEFAULT_FRAMERATE
1152 << std::endl;
1153 EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, ERROR_HEIGHT, ERROR_FRAMERATE))
1154 << "width:" << ERROR_WIDTH << "height:" << ERROR_HEIGHT << "framerate: " << ERROR_FRAMERATE
1155 << std::endl;
1156 }
1157 }
1158 }
1159
1160 /**
1161 * @tc.name: CodecList_GetVideoFrameRateRangeForSize_Vvc_001
1162 * @tc.desc: CodecList GetVideoFrameRateRangeForSize Vvc
1163 * @tc.type: FUNC
1164 */
1165 HWTEST_F(CodecListUnitTest, CodecList_GetVideoFrameRateRangeForSize_Vvc_001, TestSize.Level1)
1166 {
1167 if (!access("/system/lib64/media/", 0)) {
1168 // video decoder
1169 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1170 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1171 if (capability_ != nullptr) {
1172 Range framerateRange = capability_->GetVideoFrameRateRangeForSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
1173 EXPECT_EQ(1, framerateRange.minVal);
1174 EXPECT_EQ(120, framerateRange.maxVal);
1175
1176 framerateRange = capability_->GetVideoFrameRateRangeForSize(FRAME_RATE_WIDTH_VVC, FRAME_RATE_HEIGHT_VVC);
1177 EXPECT_EQ(1, framerateRange.minVal);
1178 EXPECT_EQ(30, framerateRange.maxVal);
1179 }
1180 }
1181 }
1182
1183 /**
1184 * @tc.name: CodecList_GetVideoFrameRateRangeForSize_Vvc_002
1185 * @tc.desc: CodecList GetVideoFrameRateRangeForSize Vvc
1186 * @tc.type: FUNC
1187 */
1188 HWTEST_F(CodecListUnitTest, CodecList_GetVideoFrameRateRangeForSize_Vvc_002, TestSize.Level1)
1189 {
1190 if (!access("/system/lib64/media/", 0)) {
1191 // video decoder
1192 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1193 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1194 if (capability_ != nullptr) {
1195 int32_t wmax = DEFAULT_WIDTH_RANGE_VVC.maxVal;
1196 int32_t hmax = DEFAULT_HEIGHT_RANGE_VVC.maxVal;
1197 Range framerateRange = capability_->GetVideoFrameRateRangeForSize(0, 0);
1198 EXPECT_EQ(0, framerateRange.minVal);
1199 EXPECT_EQ(0, framerateRange.maxVal);
1200
1201 framerateRange = capability_->GetVideoFrameRateRangeForSize(wmax + 2, hmax + 2);
1202 EXPECT_EQ(0, framerateRange.minVal);
1203 EXPECT_EQ(0, framerateRange.maxVal);
1204
1205 framerateRange = capability_->GetVideoFrameRateRangeForSize(wmax - 1, hmax - 1);
1206 EXPECT_EQ(0, framerateRange.minVal);
1207 EXPECT_EQ(0, framerateRange.maxVal);
1208
1209 framerateRange = capability_->GetVideoFrameRateRangeForSize(-2, -2);
1210 EXPECT_EQ(0, framerateRange.minVal);
1211 EXPECT_EQ(0, framerateRange.maxVal);
1212 }
1213 }
1214 }
1215
1216 /**
1217 * @tc.name: CodecList_GetVideoSupportedPixelFormats_Vvc_001
1218 * @tc.desc: CodecList GetVideoSupportedPixelFormats Vvc
1219 * @tc.type: FUNC
1220 */
1221 HWTEST_F(CodecListUnitTest, CodecList_GetVideoSupportedPixelFormats_Vvc_001, TestSize.Level1)
1222 {
1223 if (!access("/system/lib64/media/", 0)) {
1224 // video decoder
1225 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1226 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1227 if (capability_ != nullptr) {
1228 std::vector<int32_t> pixFormats = capability_->GetVideoSupportedPixelFormats();
1229 EXPECT_EQ(DEFAULT_VIDEO_VVC_PIXFORMATS, pixFormats);
1230 }
1231 }
1232 }
1233
1234 /**
1235 * @tc.name: CodecList_GetSupportedProfiles_Vvc_001
1236 * @tc.desc: CodecList GetSupportedProfiles Vvc
1237 * @tc.type: FUNC
1238 */
1239 HWTEST_F(CodecListUnitTest, CodecList_GetSupportedProfiles_Vvc_001, TestSize.Level1)
1240 {
1241 if (!access("/system/lib64/media/", 0)) {
1242 // video decoder
1243 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1244 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1245 if (capability_ != nullptr) {
1246 std::vector<int32_t> profiles = capability_->GetSupportedProfiles();
1247 EXPECT_EQ(DEFAULT_VIDEO_VVC_PROFILES, profiles);
1248 }
1249 }
1250 }
1251
1252 /**
1253 * @tc.name: CodecList_GetSupportedLevelsForProfile_Vvc_001
1254 * @tc.desc: CodecList GetSupportedLevelsForProfile Vvc
1255 * @tc.type: FUNC
1256 */
1257 HWTEST_F(CodecListUnitTest, CodecList_GetSupportedLevelsForProfile_Vvc_001, TestSize.Level1)
1258 {
1259 if (!access("/system/lib64/media/", 0)) {
1260 // video decoder
1261 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1262 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1263 if (capability_ != nullptr) {
1264 std::vector<int32_t> levels;
1265 for (auto it : DEFAULT_VIDEO_VVC_PROFILES) {
1266 levels = capability_->GetSupportedLevelsForProfile(it);
1267 EXPECT_EQ(DEFAULT_VIDEO_VVC_LEVELS, levels);
1268 }
1269 }
1270 }
1271 }
1272
1273 /**
1274 * @tc.name: CodecList_AreProfileAndLevelSupported_Vvc_001
1275 * @tc.desc: CodecList AreProfileAndLevelSupported Vvc
1276 * @tc.type: FUNC
1277 */
1278 HWTEST_F(CodecListUnitTest, CodecList_AreProfileAndLevelSupported_Vvc_001, TestSize.Level1)
1279 {
1280 if (!access("/system/lib64/media/", 0)) {
1281 // video decoder
1282 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1283 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1284 if (capability_ != nullptr) {
1285 // case 1 - 16, postive param
1286 for (auto it : DEFAULT_VIDEO_VVC_LEVELS) {
1287 EXPECT_TRUE(capability_->AreProfileAndLevelSupported(DEFAULT_VIDEO_VVC_PROFILE, it));
1288 }
1289 }
1290 }
1291 }
1292
1293 /**
1294 * @tc.name: CodecList_AreProfileAndLevelSupported_Vvc_002
1295 * @tc.desc: CodecList AreProfileAndLevelSupported Vvc
1296 * @tc.type: FUNC
1297 */
1298 HWTEST_F(CodecListUnitTest, CodecList_AreProfileAndLevelSupported_Vvc_002, TestSize.Level1)
1299 {
1300 if (!access("/system/lib64/media/", 0)) {
1301 // video decoder
1302 AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1303 capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1304 if (capability_ != nullptr) {
1305 // case 1, negative param
1306 EXPECT_FALSE(capability_->AreProfileAndLevelSupported(DEFAULT_VIDEO_VVC_PROFILE, ERROR_LEVEL));
1307 // case 2, negative param
1308 EXPECT_FALSE(capability_->AreProfileAndLevelSupported(ERROR_VIDEO_VVC_PROFILE, DEFAULT_VIDEO_VVC_LEVEL));
1309 // case 3, negative param
1310 EXPECT_FALSE(capability_->AreProfileAndLevelSupported(ERROR_VIDEO_VVC_PROFILE, ERROR_LEVEL));
1311 }
1312 }
1313 }
1314
1315 /**
1316 * @tc.name: CodecList_GetAudioSupportedSampleRateRanges_001
1317 * @tc.desc: CodecList GetAudioSupportedSampleRateRanges
1318 * @tc.type: FUNC
1319 */
1320 HWTEST_F(CodecListUnitTest, CodecList_GetAudioSupportedSampleRateRanges_001, TestSize.Level1)
1321 {
1322 capability_ = CodecListMockFactory::GetCapability(AUDIO_FLAC_MIME, false);
1323 ASSERT_NE(nullptr, capability_) << "audio decoder codeclist create fail!" << std::endl;
1324 std::vector<Range> sampleRateRanges = capability_->GetAudioSupportedSampleRateRanges();
1325 EXPECT_EQ(AUDIO_FLAC_SAMPLE_RATE_RANGE.minVal, sampleRateRanges[0].minVal);
1326 EXPECT_EQ(AUDIO_FLAC_SAMPLE_RATE_RANGE.maxVal, sampleRateRanges[0].maxVal);
1327 }