1 /*
2  * Copyright (C) 2022 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 "caps_unit_test.h"
17 #include "gtest/gtest.h"
18 #ifdef CODECLIST_CAPI_UNIT_TEST
19 #include "native_avmagic.h"
20 #endif
21 
22 using namespace std;
23 using namespace OHOS;
24 using namespace OHOS::MediaAVCodec;
25 using namespace testing::ext;
26 using namespace OHOS::MediaAVCodec::CodecListTestParam;
27 
28 namespace OHOS {
29 namespace MediaAVCodec {
SetUpTestCase(void)30 void CapsUnitTest::SetUpTestCase(void) {}
31 
TearDownTestCase(void)32 void CapsUnitTest::TearDownTestCase(void) {}
33 
SetUp(void)34 void CapsUnitTest::SetUp(void)
35 {
36     avCodecList_ = AVCodecListFactory::CreateAVCodecList();
37     ASSERT_NE(nullptr, avCodecList_);
38     codecMimeKey_ = MediaDescriptionKey::MD_KEY_CODEC_MIME;
39     bitrateKey_ = MediaDescriptionKey::MD_KEY_BITRATE;
40     widthKey_ = MediaDescriptionKey::MD_KEY_WIDTH;
41     heightKey_ = MediaDescriptionKey::MD_KEY_HEIGHT;
42     pixelFormatKey_ = MediaDescriptionKey::MD_KEY_PIXEL_FORMAT;
43     frameRateKey_ = MediaDescriptionKey::MD_KEY_FRAME_RATE;
44     channelCountKey_ = MediaDescriptionKey::MD_KEY_CHANNEL_COUNT;
45     sampleRateKey_ = MediaDescriptionKey::MD_KEY_SAMPLE_RATE;
46     CapabilityData *capabilityData =
47         avCodecList_->GetCapability(DEFAULT_VIDEO_MIME, false, AVCodecCategory::AVCODEC_NONE);
48     if (capabilityData != nullptr && capabilityData->isVendor) {
49         isHardIncluded_ = true;
50     }
51 }
52 
TearDown(void)53 void CapsUnitTest::TearDown(void) {}
54 
55 #ifdef CODECLIST_CAPI_UNIT_TEST
GetVideoDecoderCaps()56 std::vector<std::shared_ptr<VideoCaps>> CapsUnitTest::GetVideoDecoderCaps()
57 {
58     std::vector<std::shared_ptr<VideoCaps>> ret;
59     for (auto it : videoDecoderList) {
60         auto capabilityCapi = OH_AVCodec_GetCapability(it.c_str(), false);
61         ret.push_back(std::make_shared<VideoCaps>(capabilityCapi->capabilityData_));
62     }
63     return ret;
64 }
65 
GetVideoEncoderCaps()66 std::vector<std::shared_ptr<VideoCaps>> CapsUnitTest::GetVideoEncoderCaps()
67 {
68     std::vector<std::shared_ptr<VideoCaps>> ret;
69     if (isHardIncluded_) {
70         for (auto it : videoEncoderList) {
71             auto capabilityCapi = OH_AVCodec_GetCapability(it.c_str(), true);
72             ret.push_back(std::make_shared<VideoCaps>(capabilityCapi->capabilityData_));
73         }
74     }
75     return ret;
76 }
77 
GetAudioDecoderCaps()78 std::vector<std::shared_ptr<AudioCaps>> CapsUnitTest::GetAudioDecoderCaps()
79 {
80     std::vector<std::shared_ptr<AudioCaps>> ret;
81     for (auto it : audioDecoderList) {
82         auto capabilityCapi = OH_AVCodec_GetCapability(it.c_str(), false);
83         ret.push_back(std::make_shared<AudioCaps>(capabilityCapi->capabilityData_));
84     }
85     return ret;
86 }
87 
GetAudioEncoderCaps()88 std::vector<std::shared_ptr<AudioCaps>> CapsUnitTest::GetAudioEncoderCaps()
89 {
90     std::vector<std::shared_ptr<AudioCaps>> ret;
91     for (auto it : audioEncoderList) {
92         auto capabilityCapi = OH_AVCodec_GetCapability(it.c_str(), true);
93         ret.push_back(std::make_shared<AudioCaps>(capabilityCapi->capabilityData_));
94     }
95     return ret;
96 }
97 #endif
98 
99 #ifdef CODECLIST_INNER_UNIT_TEST
GetVideoDecoderCaps()100 std::vector<std::shared_ptr<VideoCaps>> CapsUnitTest::GetVideoDecoderCaps()
101 {
102     std::vector<std::shared_ptr<VideoCaps>> ret;
103     for (auto it : videoDecoderList) {
104         CapabilityData *capabilityData = avCodecList_->GetCapability(it, false, AVCodecCategory::AVCODEC_NONE);
105         ret.push_back(std::make_shared<VideoCaps>(capabilityData));
106     }
107     return ret;
108 }
109 
GetVideoEncoderCaps()110 std::vector<std::shared_ptr<VideoCaps>> CapsUnitTest::GetVideoEncoderCaps()
111 {
112     std::vector<std::shared_ptr<VideoCaps>> ret;
113     if (isHardIncluded_) {
114         for (auto it : videoEncoderList) {
115             CapabilityData *capabilityData = avCodecList_->GetCapability(it, true, AVCodecCategory::AVCODEC_NONE);
116             ret.push_back(std::make_shared<VideoCaps>(capabilityData));
117         }
118     }
119     return ret;
120 }
121 
GetAudioDecoderCaps()122 std::vector<std::shared_ptr<AudioCaps>> CapsUnitTest::GetAudioDecoderCaps()
123 {
124     std::vector<std::shared_ptr<AudioCaps>> ret;
125     for (auto it : audioDecoderList) {
126         CapabilityData *capabilityData = avCodecList_->GetCapability(it, false, AVCodecCategory::AVCODEC_NONE);
127         ret.push_back(std::make_shared<AudioCaps>(capabilityData));
128     }
129     return ret;
130 }
131 
GetAudioEncoderCaps()132 std::vector<std::shared_ptr<AudioCaps>> CapsUnitTest::GetAudioEncoderCaps()
133 {
134     std::vector<std::shared_ptr<AudioCaps>> ret;
135     for (auto it : audioEncoderList) {
136         CapabilityData *capabilityData = avCodecList_->GetCapability(it, true, AVCodecCategory::AVCODEC_NONE);
137         ret.push_back(std::make_shared<AudioCaps>(capabilityData));
138     }
139     return ret;
140 }
141 #endif
142 
CheckVideoCapsArray(const std::vector<std::shared_ptr<VideoCaps>> & videoCapsArray) const143 void CapsUnitTest::CheckVideoCapsArray(const std::vector<std::shared_ptr<VideoCaps>> &videoCapsArray) const
144 {
145     for (auto iter = videoCapsArray.begin(); iter != videoCapsArray.end(); iter++) {
146         std::shared_ptr<VideoCaps> pVideoCaps = *iter;
147         if (pVideoCaps == nullptr) {
148             cout << "pVideoCaps is nullptr" << endl;
149             break;
150         }
151         CheckVideoCaps(pVideoCaps);
152     }
153 }
154 
CheckVideoCaps(const std::shared_ptr<VideoCaps> & videoCaps) const155 void CapsUnitTest::CheckVideoCaps(const std::shared_ptr<VideoCaps> &videoCaps) const
156 {
157     std::shared_ptr<AVCodecInfo> videoCodecCaps;
158     videoCodecCaps = videoCaps->GetCodecInfo();
159     std::string codecName = videoCodecCaps->GetName();
160     EXPECT_NE("", codecName);
161     cout << "video codecName is : " << codecName << endl;
162     if (codecName.compare(AVCodecCodecName::VIDEO_DECODER_AVC_NAME) == 0) {
163         CheckAVDecAVC(videoCaps);
164     } else if (codecName.compare("OMX.hisi.video.encoder.avc") == 0) {
165         CheckAVEncAVC(videoCaps);
166     }
167 }
168 
CheckAVDecH264(const std::shared_ptr<VideoCaps> & videoCaps) const169 void CapsUnitTest::CheckAVDecH264(const std::shared_ptr<VideoCaps> &videoCaps) const
170 {
171     std::shared_ptr<AVCodecInfo> videoCodecCaps = videoCaps->GetCodecInfo();
172     EXPECT_EQ(AVCODEC_TYPE_VIDEO_DECODER, videoCodecCaps->GetType());
173     EXPECT_EQ(CodecMimeType::VIDEO_AVC, videoCodecCaps->GetMimeType());
174     EXPECT_EQ(0, videoCodecCaps->IsHardwareAccelerated());
175     EXPECT_EQ(1, videoCodecCaps->IsSoftwareOnly());
176     EXPECT_EQ(0, videoCodecCaps->IsVendor());
177     EXPECT_EQ(1, videoCaps->GetSupportedBitrate().minVal);
178     EXPECT_EQ(MAX_VIDEO_BITRATE, videoCaps->GetSupportedBitrate().maxVal);
179     EXPECT_EQ(0, videoCaps->GetSupportedWidthAlignment());
180     EXPECT_EQ(DEFAULT_WIDTH_RANGE.minVal, videoCaps->GetSupportedWidth().minVal);
181     EXPECT_EQ(DEFAULT_WIDTH_RANGE.maxVal, videoCaps->GetSupportedWidth().maxVal);
182     EXPECT_EQ(DEFAULT_HEIGHT_RANGE.minVal, videoCaps->GetSupportedHeight().minVal);
183     EXPECT_EQ(DEFAULT_HEIGHT_RANGE.maxVal, videoCaps->GetSupportedHeight().maxVal);
184     EXPECT_EQ(1, videoCaps->GetSupportedFrameRate().minVal);
185     EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.maxVal, videoCaps->GetSupportedFrameRate().maxVal);
186     EXPECT_EQ(0, videoCaps->GetSupportedEncodeQuality().minVal);
187     EXPECT_EQ(0, videoCaps->GetSupportedEncodeQuality().maxVal);
188     EXPECT_EQ(0, videoCaps->GetSupportedQuality().minVal);
189     EXPECT_EQ(0, videoCaps->GetSupportedQuality().maxVal);
190     EXPECT_EQ(0, videoCaps->GetSupportedComplexity().minVal);
191     EXPECT_EQ(0, videoCaps->GetSupportedComplexity().maxVal);
192     EXPECT_EQ(2, videoCaps->GetSupportedFormats().size());  // 2: supported formats count
193     EXPECT_EQ(3, videoCaps->GetSupportedProfiles().size()); // 3: supported profile count
194     EXPECT_EQ(0, videoCaps->GetSupportedBitrateMode().size());
195     EXPECT_EQ(0, videoCaps->GetSupportedLevels().size());
196     EXPECT_EQ(false, videoCaps->IsSupportDynamicIframe());
197     EXPECT_EQ(true, videoCaps->IsSizeSupported(videoCaps->GetSupportedWidth().minVal,
198                                                videoCaps->GetSupportedHeight().maxVal));
199 }
200 
CheckAVDecH263(const std::shared_ptr<VideoCaps> & videoCaps) const201 void CapsUnitTest::CheckAVDecH263(const std::shared_ptr<VideoCaps> &videoCaps) const
202 {
203     std::shared_ptr<AVCodecInfo> videoCodecCaps = videoCaps->GetCodecInfo();
204     EXPECT_EQ(AVCODEC_TYPE_VIDEO_DECODER, videoCodecCaps->GetType());
205     EXPECT_EQ(CodecMimeType::VIDEO_H263, videoCodecCaps->GetMimeType());
206     EXPECT_EQ(0, videoCodecCaps->IsHardwareAccelerated());
207     EXPECT_EQ(1, videoCodecCaps->IsSoftwareOnly());
208     EXPECT_EQ(0, videoCodecCaps->IsVendor());
209     EXPECT_EQ(1, videoCaps->GetSupportedBitrate().minVal);
210     EXPECT_EQ(MAX_VIDEO_BITRATE, videoCaps->GetSupportedBitrate().maxVal);
211     EXPECT_EQ(0, videoCaps->GetSupportedWidthAlignment());
212     EXPECT_EQ(0, videoCaps->GetSupportedHeightAlignment());
213     EXPECT_EQ(DEFAULT_WIDTH_RANGE.minVal, videoCaps->GetSupportedWidth().minVal);
214     EXPECT_EQ(DEFAULT_WIDTH_RANGE.maxVal, videoCaps->GetSupportedWidth().maxVal);
215     EXPECT_EQ(DEFAULT_HEIGHT_RANGE.minVal, videoCaps->GetSupportedHeight().minVal);
216     EXPECT_EQ(DEFAULT_HEIGHT_RANGE.maxVal, videoCaps->GetSupportedHeight().maxVal);
217     EXPECT_EQ(1, videoCaps->GetSupportedFrameRate().minVal);
218     EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.maxVal, videoCaps->GetSupportedFrameRate().maxVal);
219     EXPECT_EQ(0, videoCaps->GetSupportedEncodeQuality().minVal);
220     EXPECT_EQ(0, videoCaps->GetSupportedEncodeQuality().maxVal);
221     EXPECT_EQ(0, videoCaps->GetSupportedQuality().minVal);
222     EXPECT_EQ(0, videoCaps->GetSupportedQuality().maxVal);
223     EXPECT_EQ(0, videoCaps->GetSupportedComplexity().minVal);
224     EXPECT_EQ(0, videoCaps->GetSupportedComplexity().maxVal);
225     EXPECT_EQ(2, videoCaps->GetSupportedFormats().size()); // 2: supported formats count
226     EXPECT_EQ(1, videoCaps->GetSupportedProfiles().size());
227     EXPECT_EQ(0, videoCaps->GetSupportedBitrateMode().size());
228     EXPECT_EQ(0, videoCaps->GetSupportedLevels().size());
229     EXPECT_EQ(false, videoCaps->IsSupportDynamicIframe());
230     EXPECT_EQ(false, videoCaps->IsSizeSupported(videoCaps->GetSupportedWidth().minVal - 1,
231                                                 videoCaps->GetSupportedHeight().maxVal));
232 }
233 
CheckAVDecMpeg2Video(const std::shared_ptr<VideoCaps> & videoCaps) const234 void CapsUnitTest::CheckAVDecMpeg2Video(const std::shared_ptr<VideoCaps> &videoCaps) const
235 {
236     std::shared_ptr<AVCodecInfo> videoCodecCaps = videoCaps->GetCodecInfo();
237     EXPECT_EQ(AVCODEC_TYPE_VIDEO_DECODER, videoCodecCaps->GetType());
238     EXPECT_EQ(CodecMimeType::VIDEO_MPEG2, videoCodecCaps->GetMimeType());
239     EXPECT_EQ(0, videoCodecCaps->IsHardwareAccelerated());
240     EXPECT_EQ(1, videoCodecCaps->IsSoftwareOnly());
241     EXPECT_EQ(0, videoCodecCaps->IsVendor());
242     EXPECT_EQ(1, videoCaps->GetSupportedBitrate().minVal);
243     EXPECT_EQ(MAX_VIDEO_BITRATE, videoCaps->GetSupportedBitrate().maxVal);
244     EXPECT_EQ(0, videoCaps->GetSupportedWidthAlignment());
245     EXPECT_EQ(0, videoCaps->GetSupportedHeightAlignment());
246     EXPECT_EQ(DEFAULT_WIDTH_RANGE.minVal, videoCaps->GetSupportedWidth().minVal);
247     EXPECT_EQ(DEFAULT_WIDTH_RANGE.maxVal, videoCaps->GetSupportedWidth().maxVal);
248     EXPECT_EQ(DEFAULT_HEIGHT_RANGE.minVal, videoCaps->GetSupportedHeight().minVal);
249     EXPECT_EQ(DEFAULT_HEIGHT_RANGE.maxVal, videoCaps->GetSupportedHeight().maxVal);
250     EXPECT_EQ(1, videoCaps->GetSupportedFrameRate().minVal);
251     EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.maxVal, videoCaps->GetSupportedFrameRate().maxVal);
252     EXPECT_EQ(0, videoCaps->GetSupportedEncodeQuality().minVal);
253     EXPECT_EQ(0, videoCaps->GetSupportedEncodeQuality().maxVal);
254     EXPECT_EQ(0, videoCaps->GetSupportedQuality().minVal);
255     EXPECT_EQ(0, videoCaps->GetSupportedQuality().maxVal);
256     EXPECT_EQ(0, videoCaps->GetSupportedComplexity().minVal);
257     EXPECT_EQ(0, videoCaps->GetSupportedComplexity().maxVal);
258     EXPECT_EQ(2, videoCaps->GetSupportedFormats().size());  // 2: supported formats count
259     EXPECT_EQ(2, videoCaps->GetSupportedProfiles().size()); // 2: supported profile count
260     EXPECT_EQ(0, videoCaps->GetSupportedBitrateMode().size());
261     EXPECT_EQ(0, videoCaps->GetSupportedLevels().size());
262     EXPECT_EQ(false, videoCaps->IsSupportDynamicIframe());
263     EXPECT_EQ(0, videoCaps->IsSizeAndRateSupported(videoCaps->GetSupportedWidth().minVal,
264                                                    videoCaps->GetSupportedHeight().maxVal,
265                                                    videoCaps->GetSupportedFrameRate().maxVal));
266     EXPECT_EQ(false, videoCaps->IsSizeAndRateSupported(videoCaps->GetSupportedWidth().minVal - 1,
267                                                        videoCaps->GetSupportedHeight().maxVal + 1,
268                                                        videoCaps->GetSupportedFrameRate().maxVal));
269 }
270 
CheckAVDecMpeg4(const std::shared_ptr<VideoCaps> & videoCaps) const271 void CapsUnitTest::CheckAVDecMpeg4(const std::shared_ptr<VideoCaps> &videoCaps) const
272 {
273     std::shared_ptr<AVCodecInfo> videoCodecCaps = videoCaps->GetCodecInfo();
274     EXPECT_EQ(AVCODEC_TYPE_VIDEO_DECODER, videoCodecCaps->GetType());
275     EXPECT_EQ(CodecMimeType::VIDEO_MPEG4, videoCodecCaps->GetMimeType());
276     EXPECT_EQ(0, videoCodecCaps->IsHardwareAccelerated());
277     EXPECT_EQ(1, videoCodecCaps->IsSoftwareOnly());
278     EXPECT_EQ(0, videoCodecCaps->IsVendor());
279     EXPECT_EQ(1, videoCaps->GetSupportedBitrate().minVal);
280     EXPECT_EQ(MAX_VIDEO_BITRATE, videoCaps->GetSupportedBitrate().maxVal);
281     EXPECT_EQ(0, videoCaps->GetSupportedWidthAlignment());
282     EXPECT_EQ(0, videoCaps->GetSupportedHeightAlignment());
283     EXPECT_EQ(DEFAULT_WIDTH_RANGE.minVal, videoCaps->GetSupportedWidth().minVal);
284     EXPECT_EQ(DEFAULT_WIDTH_RANGE.maxVal, videoCaps->GetSupportedWidth().maxVal);
285     EXPECT_EQ(DEFAULT_HEIGHT_RANGE.minVal, videoCaps->GetSupportedHeight().minVal);
286     EXPECT_EQ(DEFAULT_HEIGHT_RANGE.maxVal, videoCaps->GetSupportedHeight().maxVal);
287     EXPECT_EQ(1, videoCaps->GetSupportedFrameRate().minVal);
288     EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.maxVal, videoCaps->GetSupportedFrameRate().maxVal);
289     EXPECT_EQ(0, videoCaps->GetSupportedEncodeQuality().minVal);
290     EXPECT_EQ(0, videoCaps->GetSupportedEncodeQuality().maxVal);
291     EXPECT_EQ(0, videoCaps->GetSupportedQuality().minVal);
292     EXPECT_EQ(0, videoCaps->GetSupportedQuality().maxVal);
293     EXPECT_EQ(0, videoCaps->GetSupportedComplexity().minVal);
294     EXPECT_EQ(0, videoCaps->GetSupportedComplexity().maxVal);
295     EXPECT_EQ(2, videoCaps->GetSupportedFormats().size());  // 2: supported formats count
296     EXPECT_EQ(2, videoCaps->GetSupportedProfiles().size()); // 2: supported profile count
297     EXPECT_EQ(0, videoCaps->GetSupportedBitrateMode().size());
298     EXPECT_EQ(0, videoCaps->GetSupportedLevels().size());
299     EXPECT_EQ(false, videoCaps->IsSupportDynamicIframe());
300     EXPECT_EQ(false, videoCaps->IsSizeAndRateSupported(videoCaps->GetSupportedWidth().minVal,
301                                                        videoCaps->GetSupportedHeight().maxVal,
302                                                        videoCaps->GetSupportedFrameRate().maxVal + 1));
303 }
304 
CheckAVDecAVC(const std::shared_ptr<VideoCaps> & videoCaps) const305 void CapsUnitTest::CheckAVDecAVC(const std::shared_ptr<VideoCaps> &videoCaps) const
306 {
307     std::shared_ptr<AVCodecInfo> videoCodecCaps = videoCaps->GetCodecInfo();
308     EXPECT_EQ(AVCODEC_TYPE_VIDEO_DECODER, videoCodecCaps->GetType());
309     EXPECT_EQ(CodecMimeType::VIDEO_AVC, videoCodecCaps->GetMimeType());
310     EXPECT_EQ(0, videoCodecCaps->IsHardwareAccelerated());
311     EXPECT_EQ(1, videoCodecCaps->IsSoftwareOnly());
312     EXPECT_EQ(0, videoCodecCaps->IsVendor());
313     EXPECT_EQ(1, videoCaps->GetSupportedBitrate().minVal);
314     EXPECT_EQ(MAX_VIDEO_BITRATE, videoCaps->GetSupportedBitrate().maxVal);
315     EXPECT_EQ(DEFAULT_WIDTH_ALIGNMENT, videoCaps->GetSupportedWidthAlignment());
316     EXPECT_EQ(DEFAULT_HEIGHT_ALIGNMENT, videoCaps->GetSupportedHeightAlignment());
317     EXPECT_EQ(DEFAULT_WIDTH_RANGE.minVal, videoCaps->GetSupportedWidth().minVal);
318     EXPECT_EQ(DEFAULT_WIDTH_RANGE.maxVal, videoCaps->GetSupportedWidth().maxVal);
319     EXPECT_EQ(DEFAULT_HEIGHT_RANGE.minVal, videoCaps->GetSupportedHeight().minVal);
320     EXPECT_EQ(DEFAULT_HEIGHT_RANGE.maxVal, videoCaps->GetSupportedHeight().maxVal);
321     EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.minVal, videoCaps->GetSupportedFrameRate().minVal);
322     EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.maxVal, videoCaps->GetSupportedFrameRate().maxVal);
323     EXPECT_EQ(0, videoCaps->GetSupportedEncodeQuality().minVal);
324     EXPECT_EQ(0, videoCaps->GetSupportedEncodeQuality().maxVal);
325     EXPECT_EQ(0, videoCaps->GetSupportedQuality().minVal);
326     EXPECT_EQ(0, videoCaps->GetSupportedQuality().maxVal);
327     EXPECT_EQ(0, videoCaps->GetSupportedComplexity().minVal);
328     EXPECT_EQ(0, videoCaps->GetSupportedComplexity().maxVal);
329     EXPECT_EQ(4, videoCaps->GetSupportedFormats().size());  // 4: supported formats count
330     EXPECT_EQ(3, videoCaps->GetSupportedProfiles().size()); // 3: supported profile count
331     EXPECT_EQ(0, videoCaps->GetSupportedBitrateMode().size());
332     EXPECT_EQ(0, videoCaps->GetSupportedLevels().size());
333     EXPECT_EQ(false, videoCaps->IsSupportDynamicIframe());
334     EXPECT_EQ(false, videoCaps->IsSizeAndRateSupported(videoCaps->GetSupportedWidth().minVal,
335                                                        videoCaps->GetSupportedHeight().maxVal,
336                                                        videoCaps->GetSupportedFrameRate().maxVal + 1));
337 }
338 
CheckAVEncAVC(const std::shared_ptr<VideoCaps> & videoCaps) const339 void CapsUnitTest::CheckAVEncAVC(const std::shared_ptr<VideoCaps> &videoCaps) const
340 {
341     std::shared_ptr<AVCodecInfo> videoCodecCaps = videoCaps->GetCodecInfo();
342     EXPECT_EQ(AVCODEC_TYPE_VIDEO_ENCODER, videoCodecCaps->GetType());
343     EXPECT_EQ(CodecMimeType::VIDEO_AVC, videoCodecCaps->GetMimeType());
344     EXPECT_EQ(1, videoCodecCaps->IsHardwareAccelerated());
345     EXPECT_EQ(0, videoCodecCaps->IsSoftwareOnly());
346     EXPECT_EQ(1, videoCodecCaps->IsVendor());
347     EXPECT_EQ(DEFAULT_BITRATE_RANGE_ENC.minVal, videoCaps->GetSupportedBitrate().minVal);
348     EXPECT_EQ(DEFAULT_BITRATE_RANGE_ENC.maxVal, videoCaps->GetSupportedBitrate().maxVal);
349     EXPECT_EQ(DEFAULT_ALIGNMENT_ENC, videoCaps->GetSupportedWidthAlignment());
350     EXPECT_EQ(DEFAULT_ALIGNMENT_ENC, videoCaps->GetSupportedHeightAlignment());
351     EXPECT_EQ(DEFAULT_WIDTH_RANGE_ENC.minVal, videoCaps->GetSupportedWidth().minVal);
352     EXPECT_GE(DEFAULT_WIDTH_RANGE_ENC.maxVal, videoCaps->GetSupportedWidth().maxVal);
353     EXPECT_EQ(DEFAULT_HEIGHT_RANGE_ENC.minVal, videoCaps->GetSupportedHeight().minVal);
354     EXPECT_LE(DEFAULT_HEIGHT_RANGE_ENC.maxVal, videoCaps->GetSupportedHeight().maxVal);
355     EXPECT_EQ(1, videoCaps->GetSupportedFrameRate().minVal);
356     EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.maxVal, videoCaps->GetSupportedFrameRate().maxVal);
357     EXPECT_EQ(DEFAULT_VIDEO_QUALITY_RANGE.minVal, videoCaps->GetSupportedEncodeQuality().minVal);
358     EXPECT_EQ(DEFAULT_VIDEO_QUALITY_RANGE.maxVal, videoCaps->GetSupportedEncodeQuality().maxVal);
359     EXPECT_EQ(0, videoCaps->GetSupportedQuality().minVal);
360     EXPECT_EQ(0, videoCaps->GetSupportedQuality().maxVal);
361     EXPECT_EQ(0, videoCaps->GetSupportedComplexity().minVal);
362     EXPECT_EQ(0, videoCaps->GetSupportedComplexity().maxVal);
363     EXPECT_TRUE(!videoCaps->GetSupportedFormats().empty());
364     EXPECT_GE(DEFAULT_BITRATEMODE_ENC, videoCaps->GetSupportedBitrateMode().size());
365     EXPECT_EQ(0, videoCaps->GetSupportedLevels().size());
366     EXPECT_EQ(false, videoCaps->IsSupportDynamicIframe());
367     EXPECT_EQ(false, videoCaps->IsSizeAndRateSupported(videoCaps->GetSupportedWidth().minVal,
368                                                        videoCaps->GetSupportedHeight().maxVal,
369                                                        videoCaps->GetSupportedFrameRate().maxVal + 1));
370 }
371 
CheckAVEncMpeg4(const std::shared_ptr<VideoCaps> & videoCaps) const372 void CapsUnitTest::CheckAVEncMpeg4(const std::shared_ptr<VideoCaps> &videoCaps) const
373 {
374     std::shared_ptr<AVCodecInfo> videoCodecCaps = videoCaps->GetCodecInfo();
375     EXPECT_EQ(AVCODEC_TYPE_VIDEO_ENCODER, videoCodecCaps->GetType());
376     EXPECT_EQ(CodecMimeType::VIDEO_MPEG4, videoCodecCaps->GetMimeType());
377     EXPECT_EQ(0, videoCodecCaps->IsHardwareAccelerated());
378     EXPECT_EQ(1, videoCodecCaps->IsSoftwareOnly());
379     EXPECT_EQ(0, videoCodecCaps->IsVendor());
380     EXPECT_EQ(1, videoCaps->GetSupportedBitrate().minVal);
381     EXPECT_EQ(MAX_VIDEO_BITRATE, videoCaps->GetSupportedBitrate().maxVal);
382     EXPECT_EQ(0, videoCaps->GetSupportedWidthAlignment());
383     EXPECT_EQ(0, videoCaps->GetSupportedHeightAlignment());
384     EXPECT_EQ(DEFAULT_WIDTH_RANGE.minVal, videoCaps->GetSupportedWidth().minVal);
385     EXPECT_EQ(DEFAULT_WIDTH, videoCaps->GetSupportedWidth().maxVal);
386     EXPECT_EQ(DEFAULT_HEIGHT_RANGE.minVal, videoCaps->GetSupportedHeight().minVal);
387     EXPECT_EQ(DEFAULT_HEIGHT, videoCaps->GetSupportedHeight().maxVal);
388     EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.minVal, videoCaps->GetSupportedFrameRate().minVal);
389     EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.maxVal, videoCaps->GetSupportedFrameRate().maxVal);
390     EXPECT_EQ(0, videoCaps->GetSupportedEncodeQuality().minVal);
391     EXPECT_EQ(0, videoCaps->GetSupportedEncodeQuality().maxVal);
392     EXPECT_EQ(0, videoCaps->GetSupportedQuality().minVal);
393     EXPECT_EQ(0, videoCaps->GetSupportedQuality().maxVal);
394     EXPECT_EQ(0, videoCaps->GetSupportedComplexity().minVal);
395     EXPECT_EQ(0, videoCaps->GetSupportedComplexity().maxVal);
396     EXPECT_EQ(2, videoCaps->GetSupportedFormats().size());     // 2: supported formats count
397     EXPECT_EQ(2, videoCaps->GetSupportedProfiles().size());    // 2: supported profile count
398     EXPECT_EQ(2, videoCaps->GetSupportedBitrateMode().size()); // 2: supported bitretemode count
399     EXPECT_EQ(0, videoCaps->GetSupportedLevels().size());
400     EXPECT_EQ(false, videoCaps->IsSupportDynamicIframe());
401 }
402 
CheckAudioCapsArray(const std::vector<std::shared_ptr<AudioCaps>> & audioCapsArray) const403 void CapsUnitTest::CheckAudioCapsArray(const std::vector<std::shared_ptr<AudioCaps>> &audioCapsArray) const
404 {
405     for (auto iter = audioCapsArray.begin(); iter != audioCapsArray.end(); iter++) {
406         std::shared_ptr<AudioCaps> pAudioCaps = *iter;
407         if (pAudioCaps == nullptr) {
408             cout << "pAudioCaps is nullptr" << endl;
409             break;
410         }
411         CheckAudioCaps(pAudioCaps);
412     }
413 }
414 
CheckAudioCaps(const std::shared_ptr<AudioCaps> & audioCaps) const415 void CapsUnitTest::CheckAudioCaps(const std::shared_ptr<AudioCaps> &audioCaps) const
416 {
417     std::shared_ptr<AVCodecInfo> audioCodecCaps;
418     audioCodecCaps = audioCaps->GetCodecInfo();
419     std::string codecName = audioCodecCaps->GetName();
420     EXPECT_NE("", codecName);
421     cout << "audio codecName is : " << codecName << endl;
422     if (codecName.compare(AVCodecCodecName::AUDIO_DECODER_MP3_NAME) == 0) {
423         CheckAVDecMP3(audioCaps);
424     } else if (codecName.compare(AVCodecCodecName::AUDIO_DECODER_AAC_NAME) == 0) {
425         CheckAVDecAAC(audioCaps);
426     } else if (codecName.compare(AVCodecCodecName::AUDIO_DECODER_VORBIS_NAME) == 0) {
427         CheckAVDecVorbis(audioCaps);
428     } else if (codecName.compare(AVCodecCodecName::AUDIO_DECODER_FLAC_NAME) == 0) {
429         CheckAVDecFlac(audioCaps);
430     } else if (codecName.compare(AVCodecCodecName::AUDIO_ENCODER_AAC_NAME) == 0) {
431         CheckAVEncAAC(audioCaps);
432     } else if (codecName.compare(AVCodecCodecName::AUDIO_DECODER_VIVID_NAME) == 0) {
433         CheckAVDecVivid(audioCaps);
434     }
435 }
436 
CheckAVDecMP3(const std::shared_ptr<AudioCaps> & audioCaps) const437 void CapsUnitTest::CheckAVDecMP3(const std::shared_ptr<AudioCaps> &audioCaps) const
438 {
439     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
440     EXPECT_EQ(AVCODEC_TYPE_AUDIO_DECODER, audioCodecCaps->GetType());
441     EXPECT_EQ(CodecMimeType::AUDIO_MPEG, audioCodecCaps->GetMimeType());
442     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
443     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
444     EXPECT_EQ(0, audioCodecCaps->IsVendor());
445     EXPECT_EQ(MIN_AUDIO_BITRATE, audioCaps->GetSupportedBitrate().minVal);
446     EXPECT_EQ(MAX_AUDIO_BITRATE, audioCaps->GetSupportedBitrate().maxVal); // 320000: max supported bitrate
447     EXPECT_EQ(1, audioCaps->GetSupportedChannel().minVal);
448     EXPECT_EQ(MAX_CHANNEL_COUNT_MP3, audioCaps->GetSupportedChannel().maxVal);
449     EXPECT_EQ(0, audioCaps->GetSupportedComplexity().minVal);
450     EXPECT_EQ(0, audioCaps->GetSupportedComplexity().maxVal);
451     EXPECT_EQ(0, audioCaps->GetSupportedFormats().size());
452     EXPECT_EQ(12, audioCaps->GetSupportedSampleRates().size()); // 12: supported samplerate count
453     EXPECT_EQ(0, audioCaps->GetSupportedProfiles().size());
454     EXPECT_EQ(0, audioCaps->GetSupportedLevels().size());
455 }
456 
CheckAVDecAAC(const std::shared_ptr<AudioCaps> & audioCaps) const457 void CapsUnitTest::CheckAVDecAAC(const std::shared_ptr<AudioCaps> &audioCaps) const
458 {
459     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
460     EXPECT_EQ(AVCODEC_TYPE_AUDIO_DECODER, audioCodecCaps->GetType());
461     EXPECT_EQ(CodecMimeType::AUDIO_AAC, audioCodecCaps->GetMimeType());
462     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
463     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
464     EXPECT_EQ(0, audioCodecCaps->IsVendor());
465     EXPECT_EQ(8000, audioCaps->GetSupportedBitrate().minVal);   // 8000: min supported bitrate
466     EXPECT_EQ(960000, audioCaps->GetSupportedBitrate().maxVal); // 960000: max supported bitrate
467     EXPECT_EQ(1, audioCaps->GetSupportedChannel().minVal);
468     EXPECT_EQ(MAX_CHANNEL_COUNT, audioCaps->GetSupportedChannel().maxVal);      // 8: max channal count
469     EXPECT_EQ(0, audioCaps->GetSupportedComplexity().minVal);
470     EXPECT_EQ(0, audioCaps->GetSupportedComplexity().maxVal);
471     EXPECT_EQ(0, audioCaps->GetSupportedFormats().size());
472     EXPECT_EQ(12, audioCaps->GetSupportedSampleRates().size()); // 12: supported samplerate count
473     EXPECT_EQ(0, audioCaps->GetSupportedProfiles().size());
474     EXPECT_EQ(0, audioCaps->GetSupportedLevels().size());
475 }
476 
CheckAVDecVorbis(const std::shared_ptr<AudioCaps> & audioCaps) const477 void CapsUnitTest::CheckAVDecVorbis(const std::shared_ptr<AudioCaps> &audioCaps) const
478 {
479     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
480     EXPECT_EQ(AVCODEC_TYPE_AUDIO_DECODER, audioCodecCaps->GetType());
481     EXPECT_EQ(CodecMimeType::AUDIO_VORBIS, audioCodecCaps->GetMimeType());
482     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
483     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
484     EXPECT_EQ(0, audioCodecCaps->IsVendor());
485     EXPECT_EQ(32000, audioCaps->GetSupportedBitrate().minVal);  // 32000: min supported bitrate
486     EXPECT_EQ(500000, audioCaps->GetSupportedBitrate().maxVal); // 500000: max supported bitrate
487     EXPECT_EQ(1, audioCaps->GetSupportedChannel().minVal);
488     EXPECT_EQ(MAX_CHANNEL_COUNT, audioCaps->GetSupportedChannel().maxVal);      // 8: max channal count
489     EXPECT_EQ(0, audioCaps->GetSupportedComplexity().minVal);
490     EXPECT_EQ(0, audioCaps->GetSupportedComplexity().maxVal);
491     EXPECT_EQ(0, audioCaps->GetSupportedFormats().size());
492     EXPECT_EQ(12, audioCaps->GetSupportedSampleRates().size()); // 12: supported samplerate count
493     EXPECT_EQ(0, audioCaps->GetSupportedProfiles().size());
494     EXPECT_EQ(0, audioCaps->GetSupportedLevels().size());
495 }
496 
CheckAVDecFlac(const std::shared_ptr<AudioCaps> & audioCaps) const497 void CapsUnitTest::CheckAVDecFlac(const std::shared_ptr<AudioCaps> &audioCaps) const
498 {
499     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
500     EXPECT_EQ(AVCODEC_TYPE_AUDIO_DECODER, audioCodecCaps->GetType());
501     EXPECT_EQ(CodecMimeType::AUDIO_FLAC, audioCodecCaps->GetMimeType());
502     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
503     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
504     EXPECT_EQ(0, audioCodecCaps->IsVendor());
505     EXPECT_EQ(1, audioCaps->GetSupportedBitrate().minVal);
506     EXPECT_EQ(2100000, audioCaps->GetSupportedBitrate().maxVal); // 2100000: max supported bitrate
507     EXPECT_EQ(1, audioCaps->GetSupportedChannel().minVal);
508     EXPECT_EQ(MAX_CHANNEL_COUNT, audioCaps->GetSupportedChannel().maxVal);       // 8: max channal count
509     EXPECT_EQ(0, audioCaps->GetSupportedComplexity().minVal);
510     EXPECT_EQ(0, audioCaps->GetSupportedComplexity().maxVal);
511     EXPECT_EQ(0, audioCaps->GetSupportedFormats().size());
512     EXPECT_EQ(13, audioCaps->GetSupportedSampleRates().size()); // 13: supported samplerate count
513     EXPECT_EQ(0, audioCaps->GetSupportedProfiles().size());
514     EXPECT_EQ(0, audioCaps->GetSupportedLevels().size());
515 }
516 
CheckAVDecOpus(const std::shared_ptr<AudioCaps> & audioCaps) const517 void CapsUnitTest::CheckAVDecOpus(const std::shared_ptr<AudioCaps> &audioCaps) const
518 {
519     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
520     EXPECT_EQ(AVCODEC_TYPE_AUDIO_DECODER, audioCodecCaps->GetType());
521     EXPECT_EQ(CodecMimeType::AUDIO_OPUS, audioCodecCaps->GetMimeType());
522     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
523     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
524     EXPECT_EQ(0, audioCodecCaps->IsVendor());
525     EXPECT_EQ(1, audioCaps->GetSupportedBitrate().minVal);
526     EXPECT_EQ(MAX_AUDIO_BITRATE, audioCaps->GetSupportedBitrate().maxVal);
527     EXPECT_EQ(1, audioCaps->GetSupportedChannel().minVal);
528     EXPECT_EQ(MAX_CHANNEL_COUNT, audioCaps->GetSupportedChannel().maxVal);
529     EXPECT_EQ(0, audioCaps->GetSupportedComplexity().minVal);
530     EXPECT_EQ(0, audioCaps->GetSupportedComplexity().maxVal);
531     EXPECT_EQ(1, audioCaps->GetSupportedFormats().size());
532     EXPECT_EQ(1, audioCaps->GetSupportedSampleRates().size());
533     EXPECT_EQ(0, audioCaps->GetSupportedProfiles().size());
534     EXPECT_EQ(0, audioCaps->GetSupportedLevels().size());
535 }
536 
CheckAVDecVivid(const std::shared_ptr<AudioCaps> & audioCaps) const537 void CapsUnitTest::CheckAVDecVivid(const std::shared_ptr<AudioCaps> &audioCaps) const
538 {
539     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
540     EXPECT_EQ(AVCODEC_TYPE_AUDIO_DECODER, audioCodecCaps->GetType());
541     EXPECT_EQ(CodecMimeType::AUDIO_AVS3DA, audioCodecCaps->GetMimeType());
542     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
543     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
544     EXPECT_EQ(0, audioCodecCaps->IsVendor());
545     EXPECT_EQ(AUDIO_MIN_BIT_RATE_VIVID_DECODER, audioCaps->GetSupportedBitrate().minVal);
546     EXPECT_EQ(AUDIO_MAX_BIT_RATE_VIVID_DECODER, audioCaps->GetSupportedBitrate().maxVal);
547     EXPECT_EQ(1, audioCaps->GetSupportedChannel().minVal);
548     EXPECT_EQ(AUDIO_MAX_CHANNEL_COUNT_VIVID, audioCaps->GetSupportedChannel().maxVal);
549     EXPECT_EQ(AUDIO_SAMPLE_RATE_COUNT_VIVID, audioCaps->GetSupportedSampleRates().size());
550 }
551 
CheckAVEncAAC(const std::shared_ptr<AudioCaps> & audioCaps) const552 void CapsUnitTest::CheckAVEncAAC(const std::shared_ptr<AudioCaps> &audioCaps) const
553 {
554     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
555     EXPECT_EQ(AVCODEC_TYPE_AUDIO_ENCODER, audioCodecCaps->GetType());
556     EXPECT_EQ(CodecMimeType::AUDIO_AAC, audioCodecCaps->GetMimeType());
557     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
558     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
559     EXPECT_EQ(0, audioCodecCaps->IsVendor());
560     EXPECT_EQ(8000, audioCaps->GetSupportedBitrate().minVal); // 8000: supported min bitrate
561     EXPECT_EQ(MAX_AUDIO_BITRATE_AAC, audioCaps->GetSupportedBitrate().maxVal);
562     EXPECT_EQ(1, audioCaps->GetSupportedChannel().minVal);
563     EXPECT_EQ(MAX_CHANNEL_COUNT, audioCaps->GetSupportedChannel().maxVal);
564     EXPECT_EQ(0, audioCaps->GetSupportedComplexity().minVal);
565     EXPECT_EQ(0, audioCaps->GetSupportedComplexity().maxVal);
566     EXPECT_EQ(0, audioCaps->GetSupportedFormats().size());
567     EXPECT_EQ(DEFAULT_SAMPLE_RATE_SIZE, audioCaps->GetSupportedSampleRates().size()); // 11: supported samplerate count
568     EXPECT_EQ(1, audioCaps->GetSupportedProfiles().size());
569     auto profilesVec = audioCaps->GetSupportedProfiles();
570     EXPECT_EQ(0, profilesVec.at(0));
571     EXPECT_EQ(0, audioCaps->GetSupportedLevels().size());
572 }
573 
CheckAVEncOpus(const std::shared_ptr<AudioCaps> & audioCaps) const574 void CapsUnitTest::CheckAVEncOpus(const std::shared_ptr<AudioCaps> &audioCaps) const
575 {
576     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
577     EXPECT_EQ(AVCODEC_TYPE_AUDIO_ENCODER, audioCodecCaps->GetType());
578     EXPECT_EQ(CodecMimeType::AUDIO_OPUS, audioCodecCaps->GetMimeType());
579     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
580     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
581     EXPECT_EQ(0, audioCodecCaps->IsVendor());
582     EXPECT_EQ(1, audioCaps->GetSupportedBitrate().minVal);
583     EXPECT_EQ(MAX_AUDIO_BITRATE, audioCaps->GetSupportedBitrate().maxVal);
584     EXPECT_EQ(1, audioCaps->GetSupportedChannel().minVal);
585     EXPECT_EQ(MAX_CHANNEL_COUNT, audioCaps->GetSupportedChannel().maxVal);
586     EXPECT_EQ(0, audioCaps->GetSupportedComplexity().minVal);
587     EXPECT_EQ(0, audioCaps->GetSupportedComplexity().maxVal);
588     EXPECT_EQ(1, audioCaps->GetSupportedFormats().size());
589     EXPECT_EQ(1, audioCaps->GetSupportedSampleRates().size());
590     EXPECT_EQ(0, audioCaps->GetSupportedProfiles().size());
591     EXPECT_EQ(0, audioCaps->GetSupportedLevels().size());
592 }
593 
594 /**
595  * @tc.name: AVCaps_GetVideoDecoderCaps_001
596  * @tc.desc: AVCdecList GetVideoDecoderCaps
597  * @tc.type: FUNC
598  * @tc.require:
599  */
600 HWTEST_F(CapsUnitTest, AVCaps_GetVideoDecoderCaps_001, TestSize.Level1)
601 {
602     std::vector<std::shared_ptr<VideoCaps>> videoDecoderArray;
603     videoDecoderArray = GetVideoDecoderCaps();
604     CheckVideoCapsArray(videoDecoderArray);
605 }
606 
607 /**
608  * @tc.name: AVCaps_GetVideoEncoderCaps_001
609  * @tc.desc: AVCdecList GetVideoEncoderCaps
610  * @tc.type: FUNC
611  * @tc.require:
612  */
613 HWTEST_F(CapsUnitTest, AVCaps_GetVideoEncoderCaps_001, TestSize.Level1)
614 {
615     std::vector<std::shared_ptr<VideoCaps>> videoEncoderArray;
616     videoEncoderArray = GetVideoEncoderCaps();
617     CheckVideoCapsArray(videoEncoderArray);
618 }
619 
620 /**
621  * @tc.name: AVCaps_GetAudioDecoderCaps_001
622  * @tc.desc: AVCdecList GetAudioDecoderCaps
623  * @tc.type: FUNC
624  * @tc.require:
625  */
626 HWTEST_F(CapsUnitTest, AVCaps_GetAudioDecoderCaps_001, TestSize.Level1)
627 {
628     std::vector<std::shared_ptr<AudioCaps>> audioDecoderArray;
629     audioDecoderArray = GetAudioDecoderCaps();
630     CheckAudioCapsArray(audioDecoderArray);
631 }
632 
633 /**
634  * @tc.name: AVCaps_GetAudioEncoderCaps_001
635  * @tc.desc: AVCdecList GetAudioEncoderCaps
636  * @tc.type: FUNC
637  * @tc.require:
638  */
639 HWTEST_F(CapsUnitTest, AVCaps_GetAudioEncoderCaps_001, TestSize.Level1)
640 {
641     std::vector<std::shared_ptr<AudioCaps>> audioEncoderArray;
642     audioEncoderArray = GetAudioEncoderCaps();
643     CheckAudioCapsArray(audioEncoderArray);
644 }
645 
646 /**
647  * @tc.name: AVCaps_GetSupportedFrameRatesFor_001
648  * @tc.desc: AVCdecList GetSupportedFrameRatesFor
649  * @tc.type: FUNC
650  * @tc.require:
651  */
652 HWTEST_F(CapsUnitTest, AVCaps_GetSupportedFrameRatesFor_001, TestSize.Level1)
653 {
654     Range ret;
655     std::vector<std::shared_ptr<VideoCaps>> videoDecoderArray = GetVideoDecoderCaps();
656     for (auto iter = videoDecoderArray.begin(); iter != videoDecoderArray.end(); iter++) {
657         std::shared_ptr<VideoCaps> pVideoCaps = *iter;
658         ret = (*iter)->GetSupportedFrameRatesFor(DEFAULT_WIDTH, DEFAULT_HEIGHT);
659         EXPECT_GE(ret.minVal, 0);
660         int32_t maxVal;
661         if (isHardIncluded_) {
662             maxVal = 240;
663         } else {
664             maxVal = 120;
665         }
666         EXPECT_LE(ret.maxVal, maxVal); // 120: max framerate for video decoder
667     }
668     std::vector<std::shared_ptr<VideoCaps>> videoEncoderArray = GetVideoEncoderCaps();
669     for (auto iter = videoEncoderArray.begin(); iter != videoEncoderArray.end(); iter++) {
670         ret = (*iter)->GetSupportedFrameRatesFor(DEFAULT_WIDTH, DEFAULT_HEIGHT);
671         EXPECT_GE(ret.minVal, 0);
672         EXPECT_LE(ret.maxVal, DEFAULT_FRAMERATE_RANGE.maxVal);
673     }
674 }
675 
676 /**
677  * @tc.name: AVCaps_GetSupportedFrameRatesFor_002
678  * @tc.desc: AVCdecList GetSupportedFrameRatesFor not supported size
679  * @tc.type: FUNC
680  * @tc.require:
681  */
682 HWTEST_F(CapsUnitTest, AVCaps_GetSupportedFrameRatesFor_002, TestSize.Level1)
683 {
684     Range ret;
685     std::vector<std::shared_ptr<VideoCaps>> videoDecoderArray = GetVideoDecoderCaps();
686     for (auto iter = videoDecoderArray.begin(); iter != videoDecoderArray.end(); iter++) {
687         std::shared_ptr<VideoCaps> pVideoCaps = *iter;
688         ret = (*iter)->GetSupportedFrameRatesFor(DEFAULT_WIDTH_RANGE.maxVal + 1, DEFAULT_HEIGHT_RANGE.maxVal + 1);
689         EXPECT_GE(ret.minVal, 0);
690         EXPECT_LE(ret.maxVal, DEFAULT_FRAMERATE_RANGE.maxVal);
691     }
692     std::vector<std::shared_ptr<VideoCaps>> videoEncoderArray = GetVideoEncoderCaps();
693     for (auto iter = videoEncoderArray.begin(); iter != videoEncoderArray.end(); iter++) {
694         ret = (*iter)->GetSupportedFrameRatesFor(DEFAULT_WIDTH_RANGE.minVal - 1, DEFAULT_HEIGHT_RANGE.minVal - 1);
695         EXPECT_GE(ret.minVal, 0);
696         EXPECT_LE(ret.maxVal, DEFAULT_FRAMERATE_RANGE.maxVal);
697     }
698 }
699 
700 /**
701  * @tc.name: AVCaps_GetPreferredFrameRate_001
702  * @tc.desc: AVCdecList GetPreferredFrameRate
703  * @tc.type: FUNC
704  * @tc.require:
705  */
706 HWTEST_F(CapsUnitTest, AVCaps_GetPreferredFrameRate_001, TestSize.Level1)
707 {
708     Range ret;
709     std::vector<std::shared_ptr<VideoCaps>> videoEncoderArray = GetVideoEncoderCaps();
710     for (auto iter = videoEncoderArray.begin(); iter != videoEncoderArray.end(); iter++) {
711         ret = (*iter)->GetPreferredFrameRate(DEFAULT_WIDTH, DEFAULT_HEIGHT);
712         EXPECT_GE(ret.minVal, 0);
713     }
714     std::vector<std::shared_ptr<VideoCaps>> videoDecoderArray = GetVideoDecoderCaps();
715     for (auto iter = videoDecoderArray.begin(); iter != videoDecoderArray.end(); iter++) {
716         ret = (*iter)->GetPreferredFrameRate(DEFAULT_WIDTH, DEFAULT_HEIGHT);
717         EXPECT_GE(ret.minVal, 0);
718     }
719 }
720 
721 /**
722  * @tc.name: AVCaps_GetPreferredFrameRate_002
723  * @tc.desc: AVCdecList GetPreferredFrameRate for not supported size
724  * @tc.type: FUNC
725  * @tc.require:
726  */
727 HWTEST_F(CapsUnitTest, AVCaps_GetPreferredFrameRate_002, TestSize.Level1)
728 {
729     Range ret;
730     std::vector<std::shared_ptr<VideoCaps>> videoEncoderArray = GetVideoEncoderCaps();
731     for (auto iter = videoEncoderArray.begin(); iter != videoEncoderArray.end(); iter++) {
732         ret = (*iter)->GetPreferredFrameRate(DEFAULT_WIDTH_RANGE.maxVal + 1, DEFAULT_HEIGHT_RANGE.maxVal + 1);
733         EXPECT_GE(ret.minVal, 0);
734     }
735     std::vector<std::shared_ptr<VideoCaps>> videoDecoderArray = GetVideoDecoderCaps();
736     for (auto iter = videoDecoderArray.begin(); iter != videoDecoderArray.end(); iter++) {
737         ret = (*iter)->GetPreferredFrameRate(DEFAULT_WIDTH_RANGE.minVal - 1, DEFAULT_HEIGHT_RANGE.minVal - 1);
738         EXPECT_GE(ret.minVal, 0);
739     }
740 }
741 
742 #ifdef CODECLIST_CAPI_UNIT_TEST
743 
744 /**
745  * @tc.name: AVCaps_NullvalToCapi_001
746  * @tc.desc: AVCdecList GetCapi for not null val
747  * @tc.type: FUNC
748  * @tc.require:
749  */
750 HWTEST_F(CapsUnitTest, AVCaps_NullvalToCapi_001, TestSize.Level1)
751 {
752     EXPECT_EQ(OH_AVCapability_IsHardware(nullptr), false);
753 
754     EXPECT_STREQ(OH_AVCapability_GetName(nullptr), "");
755 
756     EXPECT_EQ(OH_AVCapability_GetMaxSupportedInstances(nullptr), 0);
757 
758     const int32_t *sampleRates = nullptr;
759     uint32_t sampleRateNum = 0;
760     EXPECT_EQ(OH_AVCapability_GetAudioSupportedSampleRates(nullptr, &sampleRates, &sampleRateNum), AV_ERR_INVALID_VAL);
761     EXPECT_EQ(sampleRates, nullptr);
762     EXPECT_EQ(sampleRateNum, 0);
763 
764     EXPECT_EQ(OH_AVCapability_IsVideoSizeSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT), false);
765 
766     EXPECT_EQ(
767         OH_AVCapability_AreVideoSizeAndFrameRateSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FRAMERATE),
768         false);
769 
770     const int32_t *pixFormats = nullptr;
771     uint32_t pixFormatNum = -1;
772     EXPECT_EQ(OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixFormats, &pixFormatNum), AV_ERR_INVALID_VAL);
773     EXPECT_EQ(pixFormats, nullptr);
774     EXPECT_EQ(pixFormatNum, 0);
775 
776     const int32_t *profiles = nullptr;
777     uint32_t profileNum = -1;
778     EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(nullptr, &profiles, &profileNum), AV_ERR_INVALID_VAL);
779     EXPECT_EQ(profiles, nullptr);
780     EXPECT_EQ(profileNum, 0);
781 
782     const int32_t *levels = nullptr;
783     uint32_t levelNum = -1;
784     EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(nullptr, DEFAULT_VIDEO_AVC_PROFILE, &levels, &levelNum),
785               AV_ERR_INVALID_VAL);
786     EXPECT_EQ(levels, nullptr);
787     EXPECT_EQ(levelNum, 0);
788 
789     EXPECT_EQ(OH_AVCapability_AreProfileAndLevelSupported(nullptr, DEFAULT_VIDEO_AVC_PROFILE, AVC_LEVEL_1), false);
790 }
791 
792 /**
793  * @tc.name: AVCaps_NullvalToCapi_002
794  * @tc.desc: AVCdecList GetCapi for not null val
795  * @tc.type: FUNC
796  * @tc.require:
797  */
798 HWTEST_F(CapsUnitTest, AVCaps_NullvalToCapi_002, TestSize.Level1)
799 {
800     OH_AVRange range = {-1, -1};
801     EXPECT_EQ(OH_AVCapability_GetEncoderBitrateRange(nullptr, &range), AV_ERR_INVALID_VAL);
802     EXPECT_EQ(range.minVal, 0);
803     EXPECT_EQ(range.maxVal, 0);
804 
805     range = {-1, -1};
806     EXPECT_EQ(OH_AVCapability_GetEncoderQualityRange(nullptr, &range), AV_ERR_INVALID_VAL);
807     EXPECT_EQ(range.minVal, 0);
808     EXPECT_EQ(range.maxVal, 0);
809 
810     range = {-1, -1};
811     EXPECT_EQ(OH_AVCapability_GetEncoderComplexityRange(nullptr, &range), AV_ERR_INVALID_VAL);
812     EXPECT_EQ(range.minVal, 0);
813     EXPECT_EQ(range.maxVal, 0);
814 
815     range = {-1, -1};
816     EXPECT_EQ(OH_AVCapability_GetAudioChannelCountRange(nullptr, &range), AV_ERR_INVALID_VAL);
817     EXPECT_EQ(range.minVal, 0);
818     EXPECT_EQ(range.maxVal, 0);
819 
820     range = {-1, -1};
821     EXPECT_EQ(OH_AVCapability_GetVideoWidthRangeForHeight(nullptr, DEFAULT_HEIGHT, &range), AV_ERR_INVALID_VAL);
822     EXPECT_EQ(range.minVal, 0);
823     EXPECT_EQ(range.maxVal, 0);
824 
825     range = {-1, -1};
826     EXPECT_EQ(OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, DEFAULT_WIDTH, &range), AV_ERR_INVALID_VAL);
827     EXPECT_EQ(range.minVal, 0);
828     EXPECT_EQ(range.maxVal, 0);
829 
830     range = {-1, -1};
831     EXPECT_EQ(OH_AVCapability_GetVideoWidthRange(nullptr, &range), AV_ERR_INVALID_VAL);
832     EXPECT_EQ(range.minVal, 0);
833     EXPECT_EQ(range.maxVal, 0);
834 
835     range = {-1, -1};
836     EXPECT_EQ(OH_AVCapability_GetVideoHeightRange(nullptr, &range), AV_ERR_INVALID_VAL);
837     EXPECT_EQ(range.minVal, 0);
838     EXPECT_EQ(range.maxVal, 0);
839 
840     range = {-1, -1};
841     EXPECT_EQ(OH_AVCapability_GetVideoFrameRateRange(nullptr, &range), AV_ERR_INVALID_VAL);
842     EXPECT_EQ(range.minVal, 0);
843     EXPECT_EQ(range.maxVal, 0);
844 
845     range = {-1, -1};
846     EXPECT_EQ(OH_AVCapability_GetVideoFrameRateRangeForSize(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range),
847               AV_ERR_INVALID_VAL);
848     EXPECT_EQ(range.minVal, 0);
849     EXPECT_EQ(range.maxVal, 0);
850 }
851 
852 /**
853  * @tc.name: AVCaps_FeatureCheck_001
854  * @tc.desc: AVCaps feature check, valid input
855  * @tc.type: FUNC
856  * @tc.require:
857  */
858 HWTEST_F(CapsUnitTest, AVCaps_FeatureCheck_001, TestSize.Level1)
859 {
860     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
861     EXPECT_NE(cap, nullptr);
862     std::string nameStr = OH_AVCapability_GetName(cap);
863     std::string mimeStr = OH_AVCODEC_MIMETYPE_VIDEO_AVC;
864     auto it = CAPABILITY_ENCODER_HARD_NAME.find(mimeStr);
865     if (it != CAPABILITY_ENCODER_HARD_NAME.end()) {
866         if (nameStr.compare(it->second) == 0) {
867             EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, VIDEO_ENCODER_TEMPORAL_SCALABILITY), true);
868             EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, VIDEO_ENCODER_LONG_TERM_REFERENCE), true);
869             EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, VIDEO_LOW_LATENCY), true);
870         } else {
871             EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, VIDEO_ENCODER_TEMPORAL_SCALABILITY), false);
872             EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, VIDEO_ENCODER_LONG_TERM_REFERENCE), false);
873             EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, VIDEO_LOW_LATENCY), false);
874         }
875     }
876 }
877 
878 /**
879  * @tc.name: AVCaps_FeatureCheck_002
880  * @tc.desc: AVCaps feature check, invalid input
881  * @tc.type: FUNC
882  * @tc.require:
883  */
884 HWTEST_F(CapsUnitTest, AVCaps_FeatureCheck_002, TestSize.Level1)
885 {
886     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
887     EXPECT_NE(cap, nullptr);
888     EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, static_cast<OH_AVCapabilityFeature>(-1)), false);
889     EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, static_cast<OH_AVCapabilityFeature>(4)), false);
890 }
891 
892 /**
893  * @tc.name: AVCaps_FeatureProperties_001
894  * @tc.desc: AVCaps query feature with properties
895  * @tc.type: FUNC
896  * @tc.require:
897  */
898 HWTEST_F(CapsUnitTest, AVCaps_FeatureProperties_001, TestSize.Level1)
899 {
900     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
901     EXPECT_NE(cap, nullptr);
902     std::string nameStr = OH_AVCapability_GetName(cap);
903     std::string mimeStr = OH_AVCODEC_MIMETYPE_VIDEO_AVC;
904     auto it = CAPABILITY_ENCODER_HARD_NAME.find(mimeStr);
905     if (it != CAPABILITY_ENCODER_HARD_NAME.end()) {
906         if (nameStr.compare(it->second) == 0) {
907             OH_AVFormat *property = OH_AVCapability_GetFeatureProperties(cap, VIDEO_ENCODER_LONG_TERM_REFERENCE);
908             EXPECT_NE(property, nullptr);
909             int ltrNum = 0;
910             EXPECT_EQ(OH_AVFormat_GetIntValue(
911                 property, OH_FEATURE_PROPERTY_KEY_VIDEO_ENCODER_MAX_LTR_FRAME_COUNT, &ltrNum), true);
912             EXPECT_GT(ltrNum, 0);
913             OH_AVFormat_Destroy(property);
914         } else {
915             OH_AVFormat *property = OH_AVCapability_GetFeatureProperties(cap, VIDEO_ENCODER_LONG_TERM_REFERENCE);
916             EXPECT_EQ(property, nullptr);
917         }
918     }
919 }
920 
921 /**
922  * @tc.name: AVCaps_FeatureProperties_002
923  * @tc.desc: AVCaps query feature without properties
924  * @tc.type: FUNC
925  * @tc.require:
926  */
927 HWTEST_F(CapsUnitTest, AVCaps_FeatureProperties_002, TestSize.Level1)
928 {
929     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
930     EXPECT_NE(cap, nullptr);
931     OH_AVFormat *property = OH_AVCapability_GetFeatureProperties(cap, VIDEO_ENCODER_TEMPORAL_SCALABILITY);
932     EXPECT_EQ(property, nullptr);
933 }
934 
935 /**
936  * @tc.name: AVCaps_FeatureProperties_003
937  * @tc.desc: AVCaps query unspported feature properties
938  * @tc.type: FUNC
939  * @tc.require:
940  */
941 HWTEST_F(CapsUnitTest, AVCaps_FeatureProperties_003, TestSize.Level1)
942 {
943     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
944     EXPECT_NE(cap, nullptr);
945     OH_AVFormat *property = OH_AVCapability_GetFeatureProperties(cap, VIDEO_LOW_LATENCY);
946     EXPECT_EQ(property, nullptr);
947 }
948 
949 /**
950  * @tc.name: AVCaps_Levels_001
951  * @tc.desc: AVCaps query H264 hw decoder supported levels for baseline\main\high profile
952  * @tc.type: FUNC
953  * @tc.require:
954  */
955 HWTEST_F(CapsUnitTest, AVCaps_Levels_001, TestSize.Level1)
956 {
957     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
958     EXPECT_NE(cap, nullptr);
959     const int32_t *profiles = nullptr;
960     uint32_t profilesNum = -1;
961     EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(cap, &profiles, &profilesNum), AV_ERR_OK);
962     EXPECT_GT(profilesNum, 0);
963     for (int32_t i = 0; i < profilesNum; i++) {
964         int32_t profile = profiles[i];
965         EXPECT_GE(profile, AVC_PROFILE_BASELINE);
966         EXPECT_LE(profile, AVC_PROFILE_MAIN);
967         const int32_t *levels = nullptr;
968         uint32_t levelsNum = -1;
969         EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(cap, profile, &levels, &levelsNum), AV_ERR_OK);
970         EXPECT_GT(levelsNum, 0);
971         EXPECT_LE(levelsNum, AVC_LEVEL_62 + 1);
972         for (int32_t j = 0; j < levelsNum; j++) {
973             int32_t level = levels[j];
974             EXPECT_GE(level, AVC_LEVEL_1);
975             EXPECT_LE(level, AVC_LEVEL_62);
976         }
977     }
978 }
979 
980 /**
981  * @tc.name: AVCaps_Levels_002
982  * @tc.desc: AVCaps query H265 hw decoder supported levels for main\main10 profile
983  * @tc.type: FUNC
984  * @tc.require:
985  */
986 HWTEST_F(CapsUnitTest, AVCaps_Levels_002, TestSize.Level1)
987 {
988     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
989     EXPECT_NE(cap, nullptr);
990     const int32_t *profiles = nullptr;
991     uint32_t profilesNum = -1;
992     EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(cap, &profiles, &profilesNum), AV_ERR_OK);
993     EXPECT_GT(profilesNum, 0);
994     for (int32_t i = 0; i < profilesNum; i++) {
995         int32_t profile = profiles[i];
996         EXPECT_GE(profile, HEVC_PROFILE_MAIN);
997         EXPECT_LE(profile, HEVC_PROFILE_MAIN_10_HDR10_PLUS);
998         const int32_t *levels = nullptr;
999         uint32_t levelsNum = -1;
1000         EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(cap, profile, &levels, &levelsNum), AV_ERR_OK);
1001         EXPECT_GT(levelsNum, 0);
1002         EXPECT_LE(levelsNum, HEVC_LEVEL_62 + 1);
1003         for (int32_t j = 0; j < levelsNum; j++) {
1004             int32_t level = levels[j];
1005             EXPECT_GE(level, HEVC_LEVEL_1);
1006             EXPECT_LE(level, HEVC_LEVEL_62);
1007         }
1008     }
1009 }
1010 
1011 /**
1012  * @tc.name: AVCaps_Levels_003
1013  * @tc.desc: AVCaps query H264 hw encoder supported levels for baseline\main\high profile
1014  * @tc.type: FUNC
1015  * @tc.require:
1016  */
1017 HWTEST_F(CapsUnitTest, AVCaps_Levels_003, TestSize.Level1)
1018 {
1019     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1020     EXPECT_NE(cap, nullptr);
1021     const int32_t *profiles = nullptr;
1022     uint32_t profilesNum = -1;
1023     EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(cap, &profiles, &profilesNum), AV_ERR_OK);
1024     EXPECT_GT(profilesNum, 0);
1025     for (int32_t i = 0; i < profilesNum; i++) {
1026         int32_t profile = profiles[i];
1027         EXPECT_GE(profile, AVC_PROFILE_BASELINE);
1028         EXPECT_LE(profile, AVC_PROFILE_MAIN);
1029         const int32_t *levels = nullptr;
1030         uint32_t levelsNum = -1;
1031         EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(cap, profile, &levels, &levelsNum), AV_ERR_OK);
1032         EXPECT_GT(levelsNum, 0);
1033         EXPECT_LE(levelsNum, AVC_LEVEL_62 + 1);
1034         for (int32_t j = 0; j < levelsNum; j++) {
1035             int32_t level = levels[j];
1036             EXPECT_GE(level, AVC_LEVEL_1);
1037             EXPECT_LE(level, AVC_LEVEL_62);
1038         }
1039     }
1040 }
1041 
1042 /**
1043  * @tc.name: AVCaps_Levels_004
1044  * @tc.desc: AVCaps query H265 hw encoder supported levels for main\main10 profile
1045  * @tc.type: FUNC
1046  * @tc.require:
1047  */
1048 HWTEST_F(CapsUnitTest, AVCaps_Levels_004, TestSize.Level1)
1049 {
1050     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
1051     EXPECT_NE(cap, nullptr);
1052     const int32_t *profiles = nullptr;
1053     uint32_t profilesNum = -1;
1054     EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(cap, &profiles, &profilesNum), AV_ERR_OK);
1055     EXPECT_GT(profilesNum, 0);
1056     for (int32_t i = 0; i < profilesNum; i++) {
1057         int32_t profile = profiles[i];
1058         EXPECT_GE(profile, HEVC_PROFILE_MAIN);
1059         EXPECT_LE(profile, HEVC_PROFILE_MAIN_10_HDR10_PLUS);
1060         const int32_t *levels = nullptr;
1061         uint32_t levelsNum = -1;
1062         EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(cap, profile, &levels, &levelsNum), AV_ERR_OK);
1063         EXPECT_GT(levelsNum, 0);
1064         EXPECT_LE(levelsNum, HEVC_LEVEL_62 + 1);
1065         for (int32_t j = 0; j < levelsNum; j++) {
1066             int32_t level = levels[j];
1067             EXPECT_GE(level, HEVC_LEVEL_1);
1068             EXPECT_LE(level, HEVC_LEVEL_62);
1069         }
1070     }
1071 }
1072 
1073 /**
1074  * @tc.name: AVCaps_Levels_005
1075  * @tc.desc: AVCaps query H264 sw decoder supported levels for baseline\main\high profile
1076  * @tc.type: FUNC
1077  * @tc.require:
1078  */
1079 HWTEST_F(CapsUnitTest, AVCaps_Levels_005, TestSize.Level1)
1080 {
1081     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1082     EXPECT_NE(cap, nullptr);
1083     const int32_t *profiles = nullptr;
1084     uint32_t profilesNum = -1;
1085     EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(cap, &profiles, &profilesNum), AV_ERR_OK);
1086     EXPECT_GT(profilesNum, 0);
1087     for (int32_t i = 0; i < profilesNum; i++) {
1088         int32_t profile = profiles[i];
1089         EXPECT_GE(profile, AVC_PROFILE_BASELINE);
1090         EXPECT_LE(profile, AVC_PROFILE_MAIN);
1091         const int32_t *levels = nullptr;
1092         uint32_t levelsNum = -1;
1093         EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(cap, profile, &levels, &levelsNum), AV_ERR_OK);
1094         EXPECT_GT(levelsNum, 0);
1095         EXPECT_LE(levelsNum, AVC_LEVEL_62 + 1);
1096         for (int32_t j = 0; j < levelsNum; j++) {
1097             int32_t level = levels[j];
1098             EXPECT_GE(level, AVC_LEVEL_1);
1099             EXPECT_LE(level, AVC_LEVEL_62);
1100         }
1101     }
1102 }
1103 
1104 #endif
1105 } // namespace MediaAVCodec
1106 } // namespace OHOS
1107