• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <thread>
17 #include <vector>
18 #include "caps_unit_test.h"
19 #include "gtest/gtest.h"
20 #ifdef CODECLIST_CAPI_UNIT_TEST
21 #include "native_avmagic.h"
22 #endif
23 
24 using namespace std;
25 using namespace OHOS;
26 using namespace OHOS::MediaAVCodec;
27 using namespace testing::ext;
28 using namespace OHOS::MediaAVCodec::CodecListTestParam;
29 
30 namespace OHOS {
31 namespace MediaAVCodec {
SetUpTestCase(void)32 void CapsUnitTest::SetUpTestCase(void) {}
33 
TearDownTestCase(void)34 void CapsUnitTest::TearDownTestCase(void) {}
35 
SetUp(void)36 void CapsUnitTest::SetUp(void)
37 {
38     avCodecList_ = AVCodecListFactory::CreateAVCodecList();
39     ASSERT_NE(nullptr, avCodecList_);
40     codecMimeKey_ = MediaDescriptionKey::MD_KEY_CODEC_MIME;
41     bitrateKey_ = MediaDescriptionKey::MD_KEY_BITRATE;
42     widthKey_ = MediaDescriptionKey::MD_KEY_WIDTH;
43     heightKey_ = MediaDescriptionKey::MD_KEY_HEIGHT;
44     pixelFormatKey_ = MediaDescriptionKey::MD_KEY_PIXEL_FORMAT;
45     frameRateKey_ = MediaDescriptionKey::MD_KEY_FRAME_RATE;
46     channelCountKey_ = MediaDescriptionKey::MD_KEY_CHANNEL_COUNT;
47     sampleRateKey_ = MediaDescriptionKey::MD_KEY_SAMPLE_RATE;
48     CapabilityData *capabilityData =
49         avCodecList_->GetCapability(DEFAULT_VIDEO_MIME, false, AVCodecCategory::AVCODEC_NONE);
50     if (capabilityData != nullptr && capabilityData->isVendor) {
51         isHardIncluded_ = true;
52     }
53 }
54 
TearDown(void)55 void CapsUnitTest::TearDown(void) {}
56 
57 #ifdef CODECLIST_CAPI_UNIT_TEST
GetVideoDecoderCaps()58 std::vector<std::shared_ptr<VideoCaps>> CapsUnitTest::GetVideoDecoderCaps()
59 {
60     std::vector<std::shared_ptr<VideoCaps>> ret;
61     for (auto it : videoDecoderList) {
62         auto capabilityCapi = OH_AVCodec_GetCapability(it.c_str(), false);
63         ret.push_back(std::make_shared<VideoCaps>(capabilityCapi->capabilityData_));
64     }
65     return ret;
66 }
67 
GetVideoEncoderCaps()68 std::vector<std::shared_ptr<VideoCaps>> CapsUnitTest::GetVideoEncoderCaps()
69 {
70     std::vector<std::shared_ptr<VideoCaps>> ret;
71     if (isHardIncluded_) {
72         for (auto it : videoEncoderList) {
73             auto capabilityCapi = OH_AVCodec_GetCapability(it.c_str(), true);
74             ret.push_back(std::make_shared<VideoCaps>(capabilityCapi->capabilityData_));
75         }
76     }
77     return ret;
78 }
79 
GetAudioDecoderCaps()80 std::vector<std::shared_ptr<AudioCaps>> CapsUnitTest::GetAudioDecoderCaps()
81 {
82     std::vector<std::shared_ptr<AudioCaps>> ret;
83     for (auto it : audioDecoderList) {
84         auto capabilityCapi = OH_AVCodec_GetCapability(it.c_str(), false);
85         ret.push_back(std::make_shared<AudioCaps>(capabilityCapi->capabilityData_));
86     }
87     return ret;
88 }
89 
GetAudioEncoderCaps()90 std::vector<std::shared_ptr<AudioCaps>> CapsUnitTest::GetAudioEncoderCaps()
91 {
92     std::vector<std::shared_ptr<AudioCaps>> ret;
93     for (auto it : audioEncoderList) {
94         auto capabilityCapi = OH_AVCodec_GetCapability(it.c_str(), true);
95         ret.push_back(std::make_shared<AudioCaps>(capabilityCapi->capabilityData_));
96     }
97     return ret;
98 }
99 #endif
100 
101 #ifdef CODECLIST_INNER_UNIT_TEST
GetVideoDecoderCaps()102 std::vector<std::shared_ptr<VideoCaps>> CapsUnitTest::GetVideoDecoderCaps()
103 {
104     std::vector<std::shared_ptr<VideoCaps>> ret;
105     for (auto it : videoDecoderList) {
106         CapabilityData *capabilityData = avCodecList_->GetCapability(it, false, AVCodecCategory::AVCODEC_NONE);
107         ret.push_back(std::make_shared<VideoCaps>(capabilityData));
108     }
109     return ret;
110 }
111 
GetVideoEncoderCaps()112 std::vector<std::shared_ptr<VideoCaps>> CapsUnitTest::GetVideoEncoderCaps()
113 {
114     std::vector<std::shared_ptr<VideoCaps>> ret;
115     if (isHardIncluded_) {
116         for (auto it : videoEncoderList) {
117             CapabilityData *capabilityData = avCodecList_->GetCapability(it, true, AVCodecCategory::AVCODEC_NONE);
118             ret.push_back(std::make_shared<VideoCaps>(capabilityData));
119         }
120     }
121     return ret;
122 }
123 
GetAudioDecoderCaps()124 std::vector<std::shared_ptr<AudioCaps>> CapsUnitTest::GetAudioDecoderCaps()
125 {
126     std::vector<std::shared_ptr<AudioCaps>> ret;
127     for (auto it : audioDecoderList) {
128         CapabilityData *capabilityData = avCodecList_->GetCapability(it, false, AVCodecCategory::AVCODEC_NONE);
129         ret.push_back(std::make_shared<AudioCaps>(capabilityData));
130     }
131     return ret;
132 }
133 
GetAudioEncoderCaps()134 std::vector<std::shared_ptr<AudioCaps>> CapsUnitTest::GetAudioEncoderCaps()
135 {
136     std::vector<std::shared_ptr<AudioCaps>> ret;
137     for (auto it : audioEncoderList) {
138         CapabilityData *capabilityData = avCodecList_->GetCapability(it, true, AVCodecCategory::AVCODEC_NONE);
139         ret.push_back(std::make_shared<AudioCaps>(capabilityData));
140     }
141     return ret;
142 }
143 #endif
144 
CheckVideoCapsArray(const std::vector<std::shared_ptr<VideoCaps>> & videoCapsArray) const145 void CapsUnitTest::CheckVideoCapsArray(const std::vector<std::shared_ptr<VideoCaps>> &videoCapsArray) const
146 {
147     for (auto iter = videoCapsArray.begin(); iter != videoCapsArray.end(); iter++) {
148         std::shared_ptr<VideoCaps> pVideoCaps = *iter;
149         if (pVideoCaps == nullptr) {
150             cout << "pVideoCaps is nullptr" << endl;
151             break;
152         }
153         CheckVideoCaps(pVideoCaps);
154     }
155 }
156 
CheckVideoCaps(const std::shared_ptr<VideoCaps> & videoCaps) const157 void CapsUnitTest::CheckVideoCaps(const std::shared_ptr<VideoCaps> &videoCaps) const
158 {
159     std::shared_ptr<AVCodecInfo> videoCodecCaps;
160     videoCodecCaps = videoCaps->GetCodecInfo();
161     std::string codecName = videoCodecCaps->GetName();
162     EXPECT_NE("", codecName);
163     cout << "video codecName is : " << codecName << endl;
164     if (codecName.compare(AVCodecCodecName::VIDEO_DECODER_AVC_NAME) == 0) {
165         CheckAVDecAVC(videoCaps);
166     } else if (codecName.compare("OMX.hisi.video.encoder.avc") == 0) {
167         CheckAVEncAVC(videoCaps);
168     }
169 }
170 
CheckAVDecH264(const std::shared_ptr<VideoCaps> & videoCaps) const171 void CapsUnitTest::CheckAVDecH264(const std::shared_ptr<VideoCaps> &videoCaps) const
172 {
173     std::shared_ptr<AVCodecInfo> videoCodecCaps = videoCaps->GetCodecInfo();
174     EXPECT_EQ(AVCODEC_TYPE_VIDEO_DECODER, videoCodecCaps->GetType());
175     EXPECT_EQ(CodecMimeType::VIDEO_AVC, videoCodecCaps->GetMimeType());
176     EXPECT_EQ(0, videoCodecCaps->IsHardwareAccelerated());
177     EXPECT_EQ(1, videoCodecCaps->IsSoftwareOnly());
178     EXPECT_EQ(0, videoCodecCaps->IsVendor());
179     EXPECT_GE(1, videoCaps->GetSupportedBitrate().minVal);
180     EXPECT_LE(MAX_VIDEO_BITRATE, videoCaps->GetSupportedBitrate().maxVal);
181     EXPECT_LE(0, videoCaps->GetSupportedWidthAlignment());
182     EXPECT_GE(DEFAULT_WIDTH_RANGE.minVal, videoCaps->GetSupportedWidth().minVal);
183     EXPECT_LE(DEFAULT_WIDTH_RANGE.maxVal, videoCaps->GetSupportedWidth().maxVal);
184     EXPECT_GE(DEFAULT_HEIGHT_RANGE.minVal, videoCaps->GetSupportedHeight().minVal);
185     EXPECT_LE(DEFAULT_HEIGHT_RANGE.maxVal, videoCaps->GetSupportedHeight().maxVal);
186     EXPECT_GE(1, videoCaps->GetSupportedFrameRate().minVal);
187     EXPECT_LE(DEFAULT_FRAMERATE_RANGE.maxVal, videoCaps->GetSupportedFrameRate().maxVal);
188     EXPECT_LE(0, videoCaps->GetSupportedEncodeQuality().minVal);
189     EXPECT_LE(0, videoCaps->GetSupportedEncodeQuality().maxVal);
190     EXPECT_LE(0, videoCaps->GetSupportedQuality().minVal);
191     EXPECT_LE(0, videoCaps->GetSupportedQuality().maxVal);
192     EXPECT_LE(0, videoCaps->GetSupportedComplexity().minVal);
193     EXPECT_LE(0, videoCaps->GetSupportedComplexity().maxVal);
194     EXPECT_LT(0, videoCaps->GetSupportedFormats().size());
195     EXPECT_LT(0, videoCaps->GetSupportedProfiles().size());
196     EXPECT_LE(0, videoCaps->GetSupportedBitrateMode().size());
197     EXPECT_LE(0, videoCaps->GetSupportedLevels().size());
198     EXPECT_EQ(false, videoCaps->IsSupportDynamicIframe());
199     EXPECT_EQ(true, videoCaps->IsSizeSupported(videoCaps->GetSupportedWidth().minVal,
200                                                videoCaps->GetSupportedHeight().maxVal));
201 }
202 
CheckAVDecH263(const std::shared_ptr<VideoCaps> & videoCaps) const203 void CapsUnitTest::CheckAVDecH263(const std::shared_ptr<VideoCaps> &videoCaps) const
204 {
205     std::shared_ptr<AVCodecInfo> videoCodecCaps = videoCaps->GetCodecInfo();
206     EXPECT_EQ(AVCODEC_TYPE_VIDEO_DECODER, videoCodecCaps->GetType());
207     EXPECT_EQ(CodecMimeType::VIDEO_H263, videoCodecCaps->GetMimeType());
208     EXPECT_EQ(0, videoCodecCaps->IsHardwareAccelerated());
209     EXPECT_EQ(1, videoCodecCaps->IsSoftwareOnly());
210     EXPECT_EQ(0, videoCodecCaps->IsVendor());
211     EXPECT_GE(1, videoCaps->GetSupportedBitrate().minVal);
212     EXPECT_LE(MAX_VIDEO_BITRATE, videoCaps->GetSupportedBitrate().maxVal);
213     EXPECT_LE(0, videoCaps->GetSupportedWidthAlignment());
214     EXPECT_LE(0, videoCaps->GetSupportedHeightAlignment());
215     EXPECT_GE(DEFAULT_WIDTH_RANGE.minVal, videoCaps->GetSupportedWidth().minVal);
216     EXPECT_LE(DEFAULT_WIDTH_RANGE.maxVal, videoCaps->GetSupportedWidth().maxVal);
217     EXPECT_GE(DEFAULT_HEIGHT_RANGE.minVal, videoCaps->GetSupportedHeight().minVal);
218     EXPECT_LE(DEFAULT_HEIGHT_RANGE.maxVal, videoCaps->GetSupportedHeight().maxVal);
219     EXPECT_GE(1, videoCaps->GetSupportedFrameRate().minVal);
220     EXPECT_LE(DEFAULT_FRAMERATE_RANGE.maxVal, videoCaps->GetSupportedFrameRate().maxVal);
221     EXPECT_LE(0, videoCaps->GetSupportedEncodeQuality().minVal);
222     EXPECT_LE(0, videoCaps->GetSupportedEncodeQuality().maxVal);
223     EXPECT_LE(0, videoCaps->GetSupportedQuality().minVal);
224     EXPECT_LE(0, videoCaps->GetSupportedQuality().maxVal);
225     EXPECT_LE(0, videoCaps->GetSupportedComplexity().minVal);
226     EXPECT_LE(0, videoCaps->GetSupportedComplexity().maxVal);
227     EXPECT_LT(0, videoCaps->GetSupportedFormats().size());
228     EXPECT_LT(0, videoCaps->GetSupportedProfiles().size());
229     EXPECT_LE(0, videoCaps->GetSupportedBitrateMode().size());
230     EXPECT_LE(0, videoCaps->GetSupportedLevels().size());
231     EXPECT_EQ(false, videoCaps->IsSupportDynamicIframe());
232     EXPECT_EQ(false, videoCaps->IsSizeSupported(videoCaps->GetSupportedWidth().minVal - 1,
233                                                 videoCaps->GetSupportedHeight().maxVal));
234 }
235 
CheckAVDecMpeg2Video(const std::shared_ptr<VideoCaps> & videoCaps) const236 void CapsUnitTest::CheckAVDecMpeg2Video(const std::shared_ptr<VideoCaps> &videoCaps) const
237 {
238     std::shared_ptr<AVCodecInfo> videoCodecCaps = videoCaps->GetCodecInfo();
239     EXPECT_EQ(AVCODEC_TYPE_VIDEO_DECODER, videoCodecCaps->GetType());
240     EXPECT_EQ(CodecMimeType::VIDEO_MPEG2, videoCodecCaps->GetMimeType());
241     EXPECT_EQ(0, videoCodecCaps->IsHardwareAccelerated());
242     EXPECT_EQ(1, videoCodecCaps->IsSoftwareOnly());
243     EXPECT_EQ(0, videoCodecCaps->IsVendor());
244     EXPECT_GE(1, videoCaps->GetSupportedBitrate().minVal);
245     EXPECT_LE(MAX_VIDEO_BITRATE, videoCaps->GetSupportedBitrate().maxVal);
246     EXPECT_LE(0, videoCaps->GetSupportedWidthAlignment());
247     EXPECT_LE(0, videoCaps->GetSupportedHeightAlignment());
248     EXPECT_GE(DEFAULT_WIDTH_RANGE.minVal, videoCaps->GetSupportedWidth().minVal);
249     EXPECT_LE(DEFAULT_WIDTH_RANGE.maxVal, videoCaps->GetSupportedWidth().maxVal);
250     EXPECT_GE(DEFAULT_HEIGHT_RANGE.minVal, videoCaps->GetSupportedHeight().minVal);
251     EXPECT_LE(DEFAULT_HEIGHT_RANGE.maxVal, videoCaps->GetSupportedHeight().maxVal);
252     EXPECT_GE(1, videoCaps->GetSupportedFrameRate().minVal);
253     EXPECT_LE(DEFAULT_FRAMERATE_RANGE.maxVal, videoCaps->GetSupportedFrameRate().maxVal);
254     EXPECT_LE(0, videoCaps->GetSupportedEncodeQuality().minVal);
255     EXPECT_LE(0, videoCaps->GetSupportedEncodeQuality().maxVal);
256     EXPECT_LE(0, videoCaps->GetSupportedQuality().minVal);
257     EXPECT_LE(0, videoCaps->GetSupportedQuality().maxVal);
258     EXPECT_LE(0, videoCaps->GetSupportedComplexity().minVal);
259     EXPECT_LE(0, videoCaps->GetSupportedComplexity().maxVal);
260     EXPECT_LT(0, videoCaps->GetSupportedFormats().size());
261     EXPECT_LT(0, videoCaps->GetSupportedProfiles().size());
262     EXPECT_LE(0, videoCaps->GetSupportedBitrateMode().size());
263     EXPECT_LE(0, videoCaps->GetSupportedLevels().size());
264     EXPECT_EQ(false, videoCaps->IsSupportDynamicIframe());
265     EXPECT_EQ(0, videoCaps->IsSizeAndRateSupported(videoCaps->GetSupportedWidth().minVal,
266                                                    videoCaps->GetSupportedHeight().maxVal,
267                                                    videoCaps->GetSupportedFrameRate().maxVal));
268     EXPECT_EQ(false, videoCaps->IsSizeAndRateSupported(videoCaps->GetSupportedWidth().minVal - 1,
269                                                        videoCaps->GetSupportedHeight().maxVal + 1,
270                                                        videoCaps->GetSupportedFrameRate().maxVal));
271 }
272 
CheckAVDecMpeg4(const std::shared_ptr<VideoCaps> & videoCaps) const273 void CapsUnitTest::CheckAVDecMpeg4(const std::shared_ptr<VideoCaps> &videoCaps) const
274 {
275     std::shared_ptr<AVCodecInfo> videoCodecCaps = videoCaps->GetCodecInfo();
276     EXPECT_EQ(AVCODEC_TYPE_VIDEO_DECODER, videoCodecCaps->GetType());
277     EXPECT_EQ(CodecMimeType::VIDEO_MPEG4, videoCodecCaps->GetMimeType());
278     EXPECT_EQ(0, videoCodecCaps->IsHardwareAccelerated());
279     EXPECT_EQ(1, videoCodecCaps->IsSoftwareOnly());
280     EXPECT_EQ(0, videoCodecCaps->IsVendor());
281     EXPECT_GE(1, videoCaps->GetSupportedBitrate().minVal);
282     EXPECT_LE(MAX_VIDEO_BITRATE, videoCaps->GetSupportedBitrate().maxVal);
283     EXPECT_LE(0, videoCaps->GetSupportedWidthAlignment());
284     EXPECT_LE(0, videoCaps->GetSupportedHeightAlignment());
285     EXPECT_GE(DEFAULT_WIDTH_RANGE.minVal, videoCaps->GetSupportedWidth().minVal);
286     EXPECT_LE(DEFAULT_WIDTH_RANGE.maxVal, videoCaps->GetSupportedWidth().maxVal);
287     EXPECT_GE(DEFAULT_HEIGHT_RANGE.minVal, videoCaps->GetSupportedHeight().minVal);
288     EXPECT_LE(DEFAULT_HEIGHT_RANGE.maxVal, videoCaps->GetSupportedHeight().maxVal);
289     EXPECT_GE(1, videoCaps->GetSupportedFrameRate().minVal);
290     EXPECT_LE(DEFAULT_FRAMERATE_RANGE.maxVal, videoCaps->GetSupportedFrameRate().maxVal);
291     EXPECT_LE(0, videoCaps->GetSupportedEncodeQuality().minVal);
292     EXPECT_LE(0, videoCaps->GetSupportedEncodeQuality().maxVal);
293     EXPECT_LE(0, videoCaps->GetSupportedQuality().minVal);
294     EXPECT_LE(0, videoCaps->GetSupportedQuality().maxVal);
295     EXPECT_LE(0, videoCaps->GetSupportedComplexity().minVal);
296     EXPECT_LE(0, videoCaps->GetSupportedComplexity().maxVal);
297     EXPECT_LT(0, videoCaps->GetSupportedFormats().size());
298     EXPECT_LT(0, videoCaps->GetSupportedProfiles().size());
299     EXPECT_LE(0, videoCaps->GetSupportedBitrateMode().size());
300     EXPECT_LE(0, videoCaps->GetSupportedLevels().size());
301     EXPECT_EQ(false, videoCaps->IsSupportDynamicIframe());
302     EXPECT_EQ(false, videoCaps->IsSizeAndRateSupported(videoCaps->GetSupportedWidth().minVal,
303                                                        videoCaps->GetSupportedHeight().maxVal,
304                                                        videoCaps->GetSupportedFrameRate().maxVal + 1));
305 }
306 
CheckAVDecAVC(const std::shared_ptr<VideoCaps> & videoCaps) const307 void CapsUnitTest::CheckAVDecAVC(const std::shared_ptr<VideoCaps> &videoCaps) const
308 {
309     std::shared_ptr<AVCodecInfo> videoCodecCaps = videoCaps->GetCodecInfo();
310     EXPECT_EQ(AVCODEC_TYPE_VIDEO_DECODER, videoCodecCaps->GetType());
311     EXPECT_EQ(CodecMimeType::VIDEO_AVC, videoCodecCaps->GetMimeType());
312     EXPECT_EQ(0, videoCodecCaps->IsHardwareAccelerated());
313     EXPECT_EQ(1, videoCodecCaps->IsSoftwareOnly());
314     EXPECT_EQ(0, videoCodecCaps->IsVendor());
315     EXPECT_GE(1, videoCaps->GetSupportedBitrate().minVal);
316     EXPECT_LE(MAX_VIDEO_BITRATE, videoCaps->GetSupportedBitrate().maxVal);
317     EXPECT_GE(DEFAULT_WIDTH_ALIGNMENT, videoCaps->GetSupportedWidthAlignment());
318     EXPECT_GE(DEFAULT_HEIGHT_ALIGNMENT, videoCaps->GetSupportedHeightAlignment());
319     EXPECT_GE(DEFAULT_WIDTH_RANGE.minVal, videoCaps->GetSupportedWidth().minVal);
320     EXPECT_LE(DEFAULT_WIDTH_RANGE.maxVal, videoCaps->GetSupportedWidth().maxVal);
321     EXPECT_GE(DEFAULT_HEIGHT_RANGE.minVal, videoCaps->GetSupportedHeight().minVal);
322     EXPECT_LE(DEFAULT_HEIGHT_RANGE.maxVal, videoCaps->GetSupportedHeight().maxVal);
323     EXPECT_GE(DEFAULT_FRAMERATE_RANGE.minVal, videoCaps->GetSupportedFrameRate().minVal);
324     EXPECT_LE(DEFAULT_FRAMERATE_RANGE.maxVal, videoCaps->GetSupportedFrameRate().maxVal);
325     EXPECT_LE(0, videoCaps->GetSupportedEncodeQuality().minVal);
326     EXPECT_LE(0, videoCaps->GetSupportedEncodeQuality().maxVal);
327     EXPECT_LE(0, videoCaps->GetSupportedQuality().minVal);
328     EXPECT_LE(0, videoCaps->GetSupportedQuality().maxVal);
329     EXPECT_LE(0, videoCaps->GetSupportedComplexity().minVal);
330     EXPECT_LE(0, videoCaps->GetSupportedComplexity().maxVal);
331     EXPECT_LT(0, videoCaps->GetSupportedFormats().size());
332     EXPECT_LT(0, videoCaps->GetSupportedProfiles().size());
333     EXPECT_LE(0, videoCaps->GetSupportedBitrateMode().size());
334     EXPECT_LE(0, videoCaps->GetSupportedLevels().size());
335     EXPECT_EQ(false, videoCaps->IsSupportDynamicIframe());
336     EXPECT_EQ(false, videoCaps->IsSizeAndRateSupported(videoCaps->GetSupportedWidth().minVal,
337                                                        videoCaps->GetSupportedHeight().maxVal,
338                                                        videoCaps->GetSupportedFrameRate().maxVal + 1));
339 }
340 
CheckAVEncAVC(const std::shared_ptr<VideoCaps> & videoCaps) const341 void CapsUnitTest::CheckAVEncAVC(const std::shared_ptr<VideoCaps> &videoCaps) const
342 {
343     std::shared_ptr<AVCodecInfo> videoCodecCaps = videoCaps->GetCodecInfo();
344     EXPECT_EQ(AVCODEC_TYPE_VIDEO_ENCODER, videoCodecCaps->GetType());
345     EXPECT_EQ(CodecMimeType::VIDEO_AVC, videoCodecCaps->GetMimeType());
346     EXPECT_EQ(1, videoCodecCaps->IsHardwareAccelerated());
347     EXPECT_EQ(0, videoCodecCaps->IsSoftwareOnly());
348     EXPECT_EQ(1, videoCodecCaps->IsVendor());
349     EXPECT_GE(DEFAULT_BITRATE_RANGE_ENC.minVal, videoCaps->GetSupportedBitrate().minVal);
350     EXPECT_LE(DEFAULT_BITRATE_RANGE_ENC.maxVal, videoCaps->GetSupportedBitrate().maxVal);
351     EXPECT_GE(DEFAULT_ALIGNMENT_ENC, videoCaps->GetSupportedWidthAlignment());
352     EXPECT_GE(DEFAULT_ALIGNMENT_ENC, videoCaps->GetSupportedHeightAlignment());
353     EXPECT_GE(DEFAULT_WIDTH_RANGE_ENC.minVal, videoCaps->GetSupportedWidth().minVal);
354     EXPECT_LE(DEFAULT_WIDTH_RANGE_ENC.maxVal, videoCaps->GetSupportedWidth().maxVal);
355     EXPECT_GE(DEFAULT_HEIGHT_RANGE_ENC.minVal, videoCaps->GetSupportedHeight().minVal);
356     EXPECT_LE(DEFAULT_HEIGHT_RANGE_ENC.maxVal, videoCaps->GetSupportedHeight().maxVal);
357     EXPECT_GE(1, videoCaps->GetSupportedFrameRate().minVal);
358     EXPECT_LE(DEFAULT_FRAMERATE_RANGE.maxVal, videoCaps->GetSupportedFrameRate().maxVal);
359     EXPECT_GE(DEFAULT_VIDEO_QUALITY_RANGE.minVal, videoCaps->GetSupportedEncodeQuality().minVal);
360     EXPECT_LE(DEFAULT_VIDEO_QUALITY_RANGE.maxVal, videoCaps->GetSupportedEncodeQuality().maxVal);
361     EXPECT_LE(0, videoCaps->GetSupportedQuality().minVal);
362     EXPECT_LE(0, videoCaps->GetSupportedQuality().maxVal);
363     EXPECT_LE(0, videoCaps->GetSupportedComplexity().minVal);
364     EXPECT_LE(0, videoCaps->GetSupportedComplexity().maxVal);
365     EXPECT_TRUE(!videoCaps->GetSupportedFormats().empty());
366     EXPECT_LE(DEFAULT_BITRATEMODE_ENC, videoCaps->GetSupportedBitrateMode().size());
367     EXPECT_LE(0, videoCaps->GetSupportedLevels().size());
368     EXPECT_EQ(false, videoCaps->IsSupportDynamicIframe());
369     EXPECT_EQ(false, videoCaps->IsSizeAndRateSupported(videoCaps->GetSupportedWidth().minVal,
370                                                        videoCaps->GetSupportedHeight().maxVal,
371                                                        videoCaps->GetSupportedFrameRate().maxVal + 1));
372 }
373 
CheckAVEncMpeg4(const std::shared_ptr<VideoCaps> & videoCaps) const374 void CapsUnitTest::CheckAVEncMpeg4(const std::shared_ptr<VideoCaps> &videoCaps) const
375 {
376     std::shared_ptr<AVCodecInfo> videoCodecCaps = videoCaps->GetCodecInfo();
377     EXPECT_EQ(AVCODEC_TYPE_VIDEO_ENCODER, videoCodecCaps->GetType());
378     EXPECT_EQ(CodecMimeType::VIDEO_MPEG4, videoCodecCaps->GetMimeType());
379     EXPECT_EQ(0, videoCodecCaps->IsHardwareAccelerated());
380     EXPECT_EQ(1, videoCodecCaps->IsSoftwareOnly());
381     EXPECT_EQ(0, videoCodecCaps->IsVendor());
382     EXPECT_GE(1, videoCaps->GetSupportedBitrate().minVal);
383     EXPECT_LE(MAX_VIDEO_BITRATE, videoCaps->GetSupportedBitrate().maxVal);
384     EXPECT_GE(0, videoCaps->GetSupportedWidthAlignment());
385     EXPECT_GE(0, videoCaps->GetSupportedHeightAlignment());
386     EXPECT_GE(DEFAULT_WIDTH_RANGE.minVal, videoCaps->GetSupportedWidth().minVal);
387     EXPECT_LE(DEFAULT_WIDTH, videoCaps->GetSupportedWidth().maxVal);
388     EXPECT_GE(DEFAULT_HEIGHT_RANGE.minVal, videoCaps->GetSupportedHeight().minVal);
389     EXPECT_LE(DEFAULT_HEIGHT, videoCaps->GetSupportedHeight().maxVal);
390     EXPECT_GE(DEFAULT_FRAMERATE_RANGE.minVal, videoCaps->GetSupportedFrameRate().minVal);
391     EXPECT_LE(DEFAULT_FRAMERATE_RANGE.maxVal, videoCaps->GetSupportedFrameRate().maxVal);
392     EXPECT_LE(0, videoCaps->GetSupportedEncodeQuality().minVal);
393     EXPECT_LE(0, videoCaps->GetSupportedEncodeQuality().maxVal);
394     EXPECT_LE(0, videoCaps->GetSupportedQuality().minVal);
395     EXPECT_LE(0, videoCaps->GetSupportedQuality().maxVal);
396     EXPECT_LE(0, videoCaps->GetSupportedComplexity().minVal);
397     EXPECT_LE(0, videoCaps->GetSupportedComplexity().maxVal);
398     EXPECT_LT(0, videoCaps->GetSupportedFormats().size());
399     EXPECT_LT(0, videoCaps->GetSupportedProfiles().size());
400     EXPECT_LT(0, videoCaps->GetSupportedBitrateMode().size());
401     EXPECT_LE(0, videoCaps->GetSupportedLevels().size());
402     EXPECT_EQ(false, videoCaps->IsSupportDynamicIframe());
403 }
404 
CheckAudioCapsArray(const std::vector<std::shared_ptr<AudioCaps>> & audioCapsArray) const405 void CapsUnitTest::CheckAudioCapsArray(const std::vector<std::shared_ptr<AudioCaps>> &audioCapsArray) const
406 {
407     for (auto iter = audioCapsArray.begin(); iter != audioCapsArray.end(); iter++) {
408         std::shared_ptr<AudioCaps> pAudioCaps = *iter;
409         if (pAudioCaps == nullptr) {
410             cout << "pAudioCaps is nullptr" << endl;
411             break;
412         }
413         CheckAudioCaps(pAudioCaps);
414     }
415 }
416 
CheckAudioCaps(const std::shared_ptr<AudioCaps> & audioCaps) const417 void CapsUnitTest::CheckAudioCaps(const std::shared_ptr<AudioCaps> &audioCaps) const
418 {
419     std::shared_ptr<AVCodecInfo> audioCodecCaps;
420     audioCodecCaps = audioCaps->GetCodecInfo();
421     std::string codecName = audioCodecCaps->GetName();
422     EXPECT_NE("", codecName);
423     cout << "audio codecName is : " << codecName << endl;
424     if (codecName.compare(AVCodecCodecName::AUDIO_DECODER_MP3_NAME) == 0) {
425         CheckAVDecMP3(audioCaps);
426     } else if (codecName.compare(AVCodecCodecName::AUDIO_DECODER_AAC_NAME) == 0) {
427         CheckAVDecAAC(audioCaps);
428     } else if (codecName.compare(AVCodecCodecName::AUDIO_DECODER_VORBIS_NAME) == 0) {
429         CheckAVDecVorbis(audioCaps);
430     } else if (codecName.compare(AVCodecCodecName::AUDIO_DECODER_FLAC_NAME) == 0) {
431         CheckAVDecFlac(audioCaps);
432     } else if (codecName.compare(AVCodecCodecName::AUDIO_ENCODER_AAC_NAME) == 0) {
433         CheckAVEncAAC(audioCaps);
434     } else if (codecName.compare(AVCodecCodecName::AUDIO_DECODER_VIVID_NAME) == 0) {
435         CheckAVDecVivid(audioCaps);
436     } else if (codecName.compare(AVCodecCodecName::AUDIO_ENCODER_VENDOR_AAC_NAME) == 0) {
437         CheckAVEncVendorAAC(audioCaps);
438     } else if (codecName.compare(AVCodecCodecName::AUDIO_ENCODER_FLAC_NAME) == 0) {
439         CheckAVEncFlac(audioCaps);
440     } else if (codecName.compare(AVCodecCodecName::AUDIO_ENCODER_MP3_NAME) == 0) {
441         CheckAVEncMP3(audioCaps);
442     } else if (codecName.compare(AVCodecCodecName::AUDIO_ENCODER_AMRNB_NAME) == 0) {
443         CheckAVEncAmrnb(audioCaps);
444     } else if (codecName.compare(AVCodecCodecName::AUDIO_DECODER_AMRNB_NAME) == 0) {
445         CheckAVDecAmrnb(audioCaps);
446     } else if (codecName.compare(AVCodecCodecName::AUDIO_ENCODER_AMRWB_NAME) == 0) {
447         CheckAVEncAmrwb(audioCaps);
448     } else if (codecName.compare(AVCodecCodecName::AUDIO_DECODER_AMRWB_NAME) == 0) {
449         CheckAVDecAmrwb(audioCaps);
450     } else if (codecName.compare(AVCodecCodecName::AUDIO_ENCODER_OPUS_NAME) == 0) {
451         CheckAVEncOpus(audioCaps);
452     } else if (codecName.compare(AVCodecCodecName::AUDIO_DECODER_OPUS_NAME) == 0) {
453         CheckAVDecOpus(audioCaps);
454     }
455 }
456 
CheckAVDecMP3(const std::shared_ptr<AudioCaps> & audioCaps) const457 void CapsUnitTest::CheckAVDecMP3(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_MPEG, audioCodecCaps->GetMimeType());
462     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
463     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
464     EXPECT_EQ(0, audioCodecCaps->IsVendor());
465     EXPECT_GE(MIN_AUDIO_BITRATE, audioCaps->GetSupportedBitrate().minVal);
466     EXPECT_LE(MAX_AUDIO_BITRATE, audioCaps->GetSupportedBitrate().maxVal);
467     EXPECT_GE(1, audioCaps->GetSupportedChannel().minVal);
468     EXPECT_LE(MAX_CHANNEL_COUNT_MP3, audioCaps->GetSupportedChannel().maxVal);
469     EXPECT_LE(0, audioCaps->GetSupportedComplexity().minVal);
470     EXPECT_LE(0, audioCaps->GetSupportedComplexity().maxVal);
471     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
472     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
473     EXPECT_LE(0, audioCaps->GetSupportedProfiles().size());
474     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
475 }
476 
CheckAVEncMP3(const std::shared_ptr<AudioCaps> & audioCaps) const477 void CapsUnitTest::CheckAVEncMP3(const std::shared_ptr<AudioCaps> &audioCaps) const
478 {
479     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
480     EXPECT_EQ(AVCODEC_TYPE_AUDIO_ENCODER, audioCodecCaps->GetType());
481     EXPECT_EQ(CodecMimeType::AUDIO_MPEG, audioCodecCaps->GetMimeType());
482     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
483     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
484     EXPECT_EQ(0, audioCodecCaps->IsVendor());
485     EXPECT_GE(8000, audioCaps->GetSupportedBitrate().minVal); // 8000: max bitrate
486     EXPECT_LE(MAX_AUDIO_BITRATE, audioCaps->GetSupportedBitrate().maxVal);
487     EXPECT_GE(1, audioCaps->GetSupportedChannel().minVal);
488     EXPECT_LE(MAX_CHANNEL_COUNT_MP3, audioCaps->GetSupportedChannel().maxVal);
489     EXPECT_LE(0, audioCaps->GetSupportedComplexity().minVal);
490     EXPECT_LE(0, audioCaps->GetSupportedComplexity().maxVal);
491     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
492     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
493     EXPECT_LE(0, audioCaps->GetSupportedProfiles().size());
494     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
495 }
496 
CheckAVDecAAC(const std::shared_ptr<AudioCaps> & audioCaps) const497 void CapsUnitTest::CheckAVDecAAC(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_AAC, audioCodecCaps->GetMimeType());
502     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
503     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
504     EXPECT_EQ(0, audioCodecCaps->IsVendor());
505     EXPECT_GE(8000, audioCaps->GetSupportedBitrate().minVal);   // 8000: min supported bitrate
506     EXPECT_LE(960000, audioCaps->GetSupportedBitrate().maxVal); // 960000: max supported bitrate
507     EXPECT_GE(1, audioCaps->GetSupportedChannel().minVal);
508     EXPECT_LE(MAX_CHANNEL_COUNT, audioCaps->GetSupportedChannel().maxVal);      // 8: max channal count
509     EXPECT_LE(0, audioCaps->GetSupportedComplexity().minVal);
510     EXPECT_LE(0, audioCaps->GetSupportedComplexity().maxVal);
511     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
512     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
513     EXPECT_LE(0, audioCaps->GetSupportedProfiles().size());
514     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
515 }
516 
CheckAVDecVorbis(const std::shared_ptr<AudioCaps> & audioCaps) const517 void CapsUnitTest::CheckAVDecVorbis(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_VORBIS, audioCodecCaps->GetMimeType());
522     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
523     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
524     EXPECT_EQ(0, audioCodecCaps->IsVendor());
525     EXPECT_GE(32000, audioCaps->GetSupportedBitrate().minVal);  // 32000: min supported bitrate
526     EXPECT_LE(500000, audioCaps->GetSupportedBitrate().maxVal); // 500000: max supported bitrate
527     EXPECT_GE(1, audioCaps->GetSupportedChannel().minVal);
528     EXPECT_LE(MAX_CHANNEL_COUNT, audioCaps->GetSupportedChannel().maxVal);      // 8: max channal count
529     EXPECT_LE(0, audioCaps->GetSupportedComplexity().minVal);
530     EXPECT_LE(0, audioCaps->GetSupportedComplexity().maxVal);
531     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
532     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
533     EXPECT_LE(0, audioCaps->GetSupportedProfiles().size());
534     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
535 }
536 
CheckAVDecFlac(const std::shared_ptr<AudioCaps> & audioCaps) const537 void CapsUnitTest::CheckAVDecFlac(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_FLAC, audioCodecCaps->GetMimeType());
542     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
543     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
544     EXPECT_EQ(0, audioCodecCaps->IsVendor());
545     EXPECT_GE(1, audioCaps->GetSupportedBitrate().minVal);
546     EXPECT_LE(1536000, audioCaps->GetSupportedBitrate().maxVal); // 1536000: max supported bitrate
547     EXPECT_GE(1, audioCaps->GetSupportedChannel().minVal);
548     EXPECT_LE(MAX_CHANNEL_COUNT, audioCaps->GetSupportedChannel().maxVal);
549     EXPECT_LE(0, audioCaps->GetSupportedComplexity().minVal);
550     EXPECT_LE(0, audioCaps->GetSupportedComplexity().maxVal);
551     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
552     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
553     EXPECT_LE(0, audioCaps->GetSupportedProfiles().size());
554     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
555 }
556 
CheckAVEncFlac(const std::shared_ptr<AudioCaps> & audioCaps) const557 void CapsUnitTest::CheckAVEncFlac(const std::shared_ptr<AudioCaps> &audioCaps) const
558 {
559     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
560     EXPECT_EQ(AVCODEC_TYPE_AUDIO_ENCODER, audioCodecCaps->GetType());
561     EXPECT_EQ(CodecMimeType::AUDIO_FLAC, audioCodecCaps->GetMimeType());
562     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
563     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
564     EXPECT_EQ(0, audioCodecCaps->IsVendor());
565     EXPECT_GE(32000, audioCaps->GetSupportedBitrate().minVal); // 32000: min supported bitrate
566     EXPECT_LE(1536000, audioCaps->GetSupportedBitrate().maxVal); // 1536000: max supported bitrate
567     EXPECT_GE(1, audioCaps->GetSupportedChannel().minVal);
568     EXPECT_LE(MAX_CHANNEL_COUNT, audioCaps->GetSupportedChannel().maxVal);
569     EXPECT_GE(-2, audioCaps->GetSupportedComplexity().minVal); // -2: min complexity
570     EXPECT_LE(2, audioCaps->GetSupportedComplexity().maxVal); // 2: max complexity
571     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
572     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
573     EXPECT_LE(0, audioCaps->GetSupportedProfiles().size());
574     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
575 }
576 
CheckAVDecOpus(const std::shared_ptr<AudioCaps> & audioCaps) const577 void CapsUnitTest::CheckAVDecOpus(const std::shared_ptr<AudioCaps> &audioCaps) const
578 {
579     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
580     EXPECT_EQ(AVCODEC_TYPE_AUDIO_DECODER, audioCodecCaps->GetType());
581     EXPECT_EQ(CodecMimeType::AUDIO_OPUS, audioCodecCaps->GetMimeType());
582     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
583     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
584     EXPECT_EQ(0, audioCodecCaps->IsVendor());
585     EXPECT_GE(1, audioCaps->GetSupportedBitrate().minVal);
586     EXPECT_LE(MAX_AUDIO_BITRATE, audioCaps->GetSupportedBitrate().maxVal);
587     EXPECT_GE(1, audioCaps->GetSupportedChannel().minVal);
588     EXPECT_LE(2, audioCaps->GetSupportedChannel().maxVal); // 2: opus support max 2 channels
589     EXPECT_LE(0, audioCaps->GetSupportedComplexity().minVal);
590     EXPECT_LE(0, audioCaps->GetSupportedComplexity().maxVal);
591     EXPECT_LT(0, audioCaps->GetSupportedFormats().size());
592     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
593     EXPECT_LE(0, audioCaps->GetSupportedProfiles().size());
594     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
595 }
596 
CheckAVDecVivid(const std::shared_ptr<AudioCaps> & audioCaps) const597 void CapsUnitTest::CheckAVDecVivid(const std::shared_ptr<AudioCaps> &audioCaps) const
598 {
599     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
600     EXPECT_EQ(AVCODEC_TYPE_AUDIO_DECODER, audioCodecCaps->GetType());
601     EXPECT_EQ(CodecMimeType::AUDIO_AVS3DA, audioCodecCaps->GetMimeType());
602     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
603     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
604     EXPECT_EQ(0, audioCodecCaps->IsVendor());
605     EXPECT_GE(AUDIO_MIN_BIT_RATE_VIVID_DECODER, audioCaps->GetSupportedBitrate().minVal);
606     EXPECT_LE(AUDIO_MAX_BIT_RATE_VIVID_DECODER, audioCaps->GetSupportedBitrate().maxVal);
607     EXPECT_GE(1, audioCaps->GetSupportedChannel().minVal);
608     EXPECT_LE(AUDIO_MAX_CHANNEL_COUNT_VIVID, audioCaps->GetSupportedChannel().maxVal);
609     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
610 }
611 
CheckAVEncAAC(const std::shared_ptr<AudioCaps> & audioCaps) const612 void CapsUnitTest::CheckAVEncAAC(const std::shared_ptr<AudioCaps> &audioCaps) const
613 {
614     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
615     EXPECT_EQ(AVCODEC_TYPE_AUDIO_ENCODER, audioCodecCaps->GetType());
616     EXPECT_EQ(CodecMimeType::AUDIO_AAC, audioCodecCaps->GetMimeType());
617     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
618     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
619     EXPECT_EQ(0, audioCodecCaps->IsVendor());
620     EXPECT_GE(1, audioCaps->GetSupportedBitrate().minVal);
621     EXPECT_LE(MAX_AUDIO_BITRATE_AAC, audioCaps->GetSupportedBitrate().maxVal);
622     EXPECT_GE(1, audioCaps->GetSupportedChannel().minVal);
623     EXPECT_LE(MAX_CHANNEL_COUNT, audioCaps->GetSupportedChannel().maxVal);
624     EXPECT_LE(0, audioCaps->GetSupportedComplexity().minVal);
625     EXPECT_LE(0, audioCaps->GetSupportedComplexity().maxVal);
626     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
627     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
628     EXPECT_LT(0, audioCaps->GetSupportedProfiles().size());
629     auto profilesVec = audioCaps->GetSupportedProfiles();
630     EXPECT_LE(0, profilesVec.at(0));
631     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
632 }
633 
CheckAVEncVendorAAC(const std::shared_ptr<AudioCaps> & audioCaps) const634 void CapsUnitTest::CheckAVEncVendorAAC(const std::shared_ptr<AudioCaps> &audioCaps) const
635 {
636     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
637     EXPECT_EQ(AVCODEC_TYPE_AUDIO_ENCODER, audioCodecCaps->GetType());
638     EXPECT_EQ(CodecMimeType::AUDIO_AAC, audioCodecCaps->GetMimeType());
639     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
640     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
641     EXPECT_EQ(0, audioCodecCaps->IsVendor());
642     EXPECT_GE(1, audioCaps->GetSupportedBitrate().minVal);
643     EXPECT_LE(MAX_AUDIO_BITRATE_AAC, audioCaps->GetSupportedBitrate().maxVal);
644     EXPECT_GE(1, audioCaps->GetSupportedChannel().minVal);
645     EXPECT_LE(MAX_CHANNEL_COUNT, audioCaps->GetSupportedChannel().maxVal);
646     EXPECT_LE(0, audioCaps->GetSupportedComplexity().minVal);
647     EXPECT_LE(0, audioCaps->GetSupportedComplexity().maxVal);
648     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
649     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
650     EXPECT_LT(0, audioCaps->GetSupportedProfiles().size());
651     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
652 }
653 
CheckAVEncOpus(const std::shared_ptr<AudioCaps> & audioCaps) const654 void CapsUnitTest::CheckAVEncOpus(const std::shared_ptr<AudioCaps> &audioCaps) const
655 {
656     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
657     EXPECT_EQ(AVCODEC_TYPE_AUDIO_ENCODER, audioCodecCaps->GetType());
658     EXPECT_EQ(CodecMimeType::AUDIO_OPUS, audioCodecCaps->GetMimeType());
659     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
660     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
661     EXPECT_EQ(0, audioCodecCaps->IsVendor());
662     EXPECT_GE(6000, audioCaps->GetSupportedBitrate().minVal); // 6000: opus min bitrate
663     EXPECT_LE(510000, audioCaps->GetSupportedBitrate().maxVal); // 510000: opus max bitrate
664     EXPECT_GE(1, audioCaps->GetSupportedChannel().minVal);
665     EXPECT_LE(2, audioCaps->GetSupportedChannel().maxVal); // 2: opus support max 2 channels
666     EXPECT_GE(1, audioCaps->GetSupportedComplexity().minVal);
667     EXPECT_LE(10, audioCaps->GetSupportedComplexity().maxVal); // 10: opus complexity max
668     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
669     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
670     EXPECT_LT(0, audioCaps->GetSupportedProfiles().size());
671     EXPECT_LT(0, audioCaps->GetSupportedLevels().size());
672 }
673 
CheckAVEncAmrnb(const std::shared_ptr<AudioCaps> & audioCaps) const674 void CapsUnitTest::CheckAVEncAmrnb(const std::shared_ptr<AudioCaps> &audioCaps) const
675 {
676     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
677     EXPECT_EQ(AVCODEC_TYPE_AUDIO_ENCODER, audioCodecCaps->GetType());
678     EXPECT_EQ(CodecMimeType::AUDIO_AMR_NB, audioCodecCaps->GetMimeType());
679     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
680     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
681     EXPECT_EQ(0, audioCodecCaps->IsVendor());
682     EXPECT_GE(4750, audioCaps->GetSupportedBitrate().minVal); // 4750: amrnb min bitrate
683     EXPECT_LT(12200, audioCaps->GetSupportedBitrate().maxVal); // 12200: amrnb max bitrate
684     EXPECT_GE(1, audioCaps->GetSupportedChannel().minVal);
685     EXPECT_LE(1, audioCaps->GetSupportedChannel().maxVal);
686     EXPECT_LE(0, audioCaps->GetSupportedComplexity().minVal);
687     EXPECT_LE(0, audioCaps->GetSupportedComplexity().maxVal);
688     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
689     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
690     EXPECT_LE(0, audioCaps->GetSupportedProfiles().size());
691     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
692 }
693 
CheckAVDecAmrnb(const std::shared_ptr<AudioCaps> & audioCaps) const694 void CapsUnitTest::CheckAVDecAmrnb(const std::shared_ptr<AudioCaps> &audioCaps) const
695 {
696     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
697     EXPECT_EQ(AVCODEC_TYPE_AUDIO_DECODER, audioCodecCaps->GetType());
698     EXPECT_EQ(CodecMimeType::AUDIO_AMR_NB, audioCodecCaps->GetMimeType());
699     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
700     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
701     EXPECT_EQ(0, audioCodecCaps->IsVendor());
702     EXPECT_GE(4750, audioCaps->GetSupportedBitrate().minVal); // 4750: amrnb min bitrate
703     EXPECT_LE(12200, audioCaps->GetSupportedBitrate().maxVal); // 12200: amrnb max bitrate
704     EXPECT_LT(0, audioCaps->GetSupportedChannel().minVal);
705     EXPECT_LT(0, audioCaps->GetSupportedChannel().maxVal);
706     EXPECT_LE(0, audioCaps->GetSupportedComplexity().minVal);
707     EXPECT_LE(0, audioCaps->GetSupportedComplexity().maxVal);
708     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
709     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
710     EXPECT_LE(0, audioCaps->GetSupportedProfiles().size());
711     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
712 }
713 
CheckAVEncAmrwb(const std::shared_ptr<AudioCaps> & audioCaps) const714 void CapsUnitTest::CheckAVEncAmrwb(const std::shared_ptr<AudioCaps> &audioCaps) const
715 {
716     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
717     EXPECT_EQ(AVCODEC_TYPE_AUDIO_ENCODER, audioCodecCaps->GetType());
718     EXPECT_EQ(CodecMimeType::AUDIO_AMR_WB, audioCodecCaps->GetMimeType());
719     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
720     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
721     EXPECT_EQ(0, audioCodecCaps->IsVendor());
722     EXPECT_GE(6600, audioCaps->GetSupportedBitrate().minVal); // 6600: amrwb min bitrate
723     EXPECT_LE(23850, audioCaps->GetSupportedBitrate().maxVal); // 23850: amrwb max bitrate
724     EXPECT_LT(0, audioCaps->GetSupportedChannel().minVal);
725     EXPECT_LT(0, audioCaps->GetSupportedChannel().maxVal);
726     EXPECT_LE(0, audioCaps->GetSupportedComplexity().minVal);
727     EXPECT_LE(0, audioCaps->GetSupportedComplexity().maxVal);
728     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
729     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
730     EXPECT_LE(0, audioCaps->GetSupportedProfiles().size());
731     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
732 }
733 
CheckAVDecAmrwb(const std::shared_ptr<AudioCaps> & audioCaps) const734 void CapsUnitTest::CheckAVDecAmrwb(const std::shared_ptr<AudioCaps> &audioCaps) const
735 {
736     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
737     EXPECT_EQ(AVCODEC_TYPE_AUDIO_DECODER, audioCodecCaps->GetType());
738     EXPECT_EQ(CodecMimeType::AUDIO_AMR_WB, audioCodecCaps->GetMimeType());
739     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
740     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
741     EXPECT_EQ(0, audioCodecCaps->IsVendor());
742     EXPECT_GE(6600, audioCaps->GetSupportedBitrate().minVal); // 6600: amrwb min bitrate
743     EXPECT_LE(23850, audioCaps->GetSupportedBitrate().maxVal); // 23850: amrwb max bitrate
744     EXPECT_LT(0, audioCaps->GetSupportedChannel().minVal);
745     EXPECT_LT(0, audioCaps->GetSupportedChannel().maxVal);
746     EXPECT_LE(0, audioCaps->GetSupportedComplexity().minVal);
747     EXPECT_LE(0, audioCaps->GetSupportedComplexity().maxVal);
748     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
749     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
750     EXPECT_LE(0, audioCaps->GetSupportedProfiles().size());
751     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
752 }
753 
CheckAVEncG711mu(const std::shared_ptr<AudioCaps> & audioCaps) const754 void CapsUnitTest::CheckAVEncG711mu(const std::shared_ptr<AudioCaps> &audioCaps) const
755 {
756     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
757     EXPECT_EQ(AVCODEC_TYPE_AUDIO_ENCODER, audioCodecCaps->GetType());
758     EXPECT_EQ(CodecMimeType::AUDIO_G711MU, audioCodecCaps->GetMimeType());
759     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
760     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
761     EXPECT_EQ(0, audioCodecCaps->IsVendor());
762     EXPECT_GE(64000, audioCaps->GetSupportedBitrate().minVal); // 64000: g711mu only support 64000 bitrate
763     EXPECT_LE(64000, audioCaps->GetSupportedBitrate().maxVal); // 64000: g711mu only support 64000 bitrate
764     EXPECT_LT(0, audioCaps->GetSupportedChannel().minVal);
765     EXPECT_LT(0, audioCaps->GetSupportedChannel().maxVal);
766     EXPECT_LE(0, audioCaps->GetSupportedComplexity().minVal);
767     EXPECT_LE(0, audioCaps->GetSupportedComplexity().maxVal);
768     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
769     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
770     EXPECT_LE(0, audioCaps->GetSupportedProfiles().size());
771     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
772 }
773 
CheckAVDecG711mu(const std::shared_ptr<AudioCaps> & audioCaps) const774 void CapsUnitTest::CheckAVDecG711mu(const std::shared_ptr<AudioCaps> &audioCaps) const
775 {
776     std::shared_ptr<AVCodecInfo> audioCodecCaps = audioCaps->GetCodecInfo();
777     EXPECT_EQ(AVCODEC_TYPE_AUDIO_DECODER, audioCodecCaps->GetType());
778     EXPECT_EQ(CodecMimeType::AUDIO_G711MU, audioCodecCaps->GetMimeType());
779     EXPECT_EQ(0, audioCodecCaps->IsHardwareAccelerated());
780     EXPECT_EQ(1, audioCodecCaps->IsSoftwareOnly());
781     EXPECT_EQ(0, audioCodecCaps->IsVendor());
782     EXPECT_GE(64000, audioCaps->GetSupportedBitrate().minVal); // 64000: g711mu only support 64000 bitrate
783     EXPECT_LE(64000, audioCaps->GetSupportedBitrate().maxVal); // 64000: g711mu only support 64000 bitrate
784     EXPECT_LT(0, audioCaps->GetSupportedChannel().minVal);
785     EXPECT_LT(0, audioCaps->GetSupportedChannel().maxVal);
786     EXPECT_LE(0, audioCaps->GetSupportedComplexity().minVal);
787     EXPECT_LE(0, audioCaps->GetSupportedComplexity().maxVal);
788     EXPECT_LE(0, audioCaps->GetSupportedFormats().size());
789     EXPECT_LT(0, audioCaps->GetSupportedSampleRates().size());
790     EXPECT_LE(0, audioCaps->GetSupportedProfiles().size());
791     EXPECT_LE(0, audioCaps->GetSupportedLevels().size());
792 }
793 
794 /**
795  * @tc.name: AVCaps_GetVideoDecoderCaps_001
796  * @tc.desc: AVCdecList GetVideoDecoderCaps
797  * @tc.type: FUNC
798  * @tc.require:
799  */
800 HWTEST_F(CapsUnitTest, AVCaps_GetVideoDecoderCaps_001, TestSize.Level1)
801 {
802     std::vector<std::shared_ptr<VideoCaps>> videoDecoderArray;
803     videoDecoderArray = GetVideoDecoderCaps();
804     CheckVideoCapsArray(videoDecoderArray);
805 }
806 
807 /**
808  * @tc.name: AVCaps_GetVideoEncoderCaps_001
809  * @tc.desc: AVCdecList GetVideoEncoderCaps
810  * @tc.type: FUNC
811  * @tc.require:
812  */
813 HWTEST_F(CapsUnitTest, AVCaps_GetVideoEncoderCaps_001, TestSize.Level1)
814 {
815     std::vector<std::shared_ptr<VideoCaps>> videoEncoderArray;
816     videoEncoderArray = GetVideoEncoderCaps();
817     CheckVideoCapsArray(videoEncoderArray);
818 }
819 
820 /**
821  * @tc.name: AVCaps_GetAudioDecoderCaps_001
822  * @tc.desc: AVCdecList GetAudioDecoderCaps
823  * @tc.type: FUNC
824  * @tc.require:
825  */
826 HWTEST_F(CapsUnitTest, AVCaps_GetAudioDecoderCaps_001, TestSize.Level1)
827 {
828     std::vector<std::shared_ptr<AudioCaps>> audioDecoderArray;
829     audioDecoderArray = GetAudioDecoderCaps();
830     CheckAudioCapsArray(audioDecoderArray);
831 }
832 
833 /**
834  * @tc.name: AVCaps_GetAudioEncoderCaps_001
835  * @tc.desc: AVCdecList GetAudioEncoderCaps
836  * @tc.type: FUNC
837  * @tc.require:
838  */
839 HWTEST_F(CapsUnitTest, AVCaps_GetAudioEncoderCaps_001, TestSize.Level1)
840 {
841     std::vector<std::shared_ptr<AudioCaps>> audioEncoderArray;
842     audioEncoderArray = GetAudioEncoderCaps();
843     CheckAudioCapsArray(audioEncoderArray);
844 }
845 
846 /**
847  * @tc.name: AVCaps_GetSupportedFrameRatesFor_001
848  * @tc.desc: AVCdecList GetSupportedFrameRatesFor
849  * @tc.type: FUNC
850  * @tc.require:
851  */
852 HWTEST_F(CapsUnitTest, AVCaps_GetSupportedFrameRatesFor_001, TestSize.Level1)
853 {
854     Range ret;
855     std::vector<std::shared_ptr<VideoCaps>> videoDecoderArray = GetVideoDecoderCaps();
856     for (auto iter = videoDecoderArray.begin(); iter != videoDecoderArray.end(); iter++) {
857         std::shared_ptr<VideoCaps> pVideoCaps = *iter;
858         ret = (*iter)->GetSupportedFrameRatesFor(DEFAULT_WIDTH, DEFAULT_HEIGHT);
859         EXPECT_GE(ret.minVal, 0);
860         int32_t maxVal;
861         if (isHardIncluded_) {
862             maxVal = 240;
863         } else {
864             maxVal = 120;
865         }
866         EXPECT_LE(ret.maxVal, maxVal); // 120: max framerate for video decoder
867     }
868     std::vector<std::shared_ptr<VideoCaps>> videoEncoderArray = GetVideoEncoderCaps();
869     for (auto iter = videoEncoderArray.begin(); iter != videoEncoderArray.end(); iter++) {
870         ret = (*iter)->GetSupportedFrameRatesFor(DEFAULT_WIDTH, DEFAULT_HEIGHT);
871         EXPECT_GE(ret.minVal, 0);
872         EXPECT_LE(ret.maxVal, DEFAULT_FRAMERATE_RANGE.maxVal);
873     }
874 }
875 
876 /**
877  * @tc.name: AVCaps_GetSupportedFrameRatesFor_002
878  * @tc.desc: AVCdecList GetSupportedFrameRatesFor not supported size
879  * @tc.type: FUNC
880  * @tc.require:
881  */
882 HWTEST_F(CapsUnitTest, AVCaps_GetSupportedFrameRatesFor_002, TestSize.Level1)
883 {
884     Range ret;
885     std::vector<std::shared_ptr<VideoCaps>> videoDecoderArray = GetVideoDecoderCaps();
886     for (auto iter = videoDecoderArray.begin(); iter != videoDecoderArray.end(); iter++) {
887         std::shared_ptr<VideoCaps> pVideoCaps = *iter;
888         ret = (*iter)->GetSupportedFrameRatesFor(DEFAULT_WIDTH_RANGE.maxVal + 1, DEFAULT_HEIGHT_RANGE.maxVal + 1);
889         EXPECT_GE(ret.minVal, 0);
890         EXPECT_LE(ret.maxVal, DEFAULT_FRAMERATE_RANGE.maxVal);
891     }
892     std::vector<std::shared_ptr<VideoCaps>> videoEncoderArray = GetVideoEncoderCaps();
893     for (auto iter = videoEncoderArray.begin(); iter != videoEncoderArray.end(); iter++) {
894         ret = (*iter)->GetSupportedFrameRatesFor(DEFAULT_WIDTH_RANGE.minVal - 1, DEFAULT_HEIGHT_RANGE.minVal - 1);
895         EXPECT_GE(ret.minVal, 0);
896         EXPECT_LE(ret.maxVal, DEFAULT_FRAMERATE_RANGE.maxVal);
897     }
898 }
899 
900 /**
901  * @tc.name: AVCaps_GetPreferredFrameRate_001
902  * @tc.desc: AVCdecList GetPreferredFrameRate
903  * @tc.type: FUNC
904  * @tc.require:
905  */
906 HWTEST_F(CapsUnitTest, AVCaps_GetPreferredFrameRate_001, TestSize.Level1)
907 {
908     Range ret;
909     std::vector<std::shared_ptr<VideoCaps>> videoEncoderArray = GetVideoEncoderCaps();
910     for (auto iter = videoEncoderArray.begin(); iter != videoEncoderArray.end(); iter++) {
911         ret = (*iter)->GetPreferredFrameRate(DEFAULT_WIDTH, DEFAULT_HEIGHT);
912         EXPECT_GE(ret.minVal, 0);
913     }
914     std::vector<std::shared_ptr<VideoCaps>> videoDecoderArray = GetVideoDecoderCaps();
915     for (auto iter = videoDecoderArray.begin(); iter != videoDecoderArray.end(); iter++) {
916         ret = (*iter)->GetPreferredFrameRate(DEFAULT_WIDTH, DEFAULT_HEIGHT);
917         EXPECT_GE(ret.minVal, 0);
918     }
919 }
920 
921 /**
922  * @tc.name: AVCaps_GetPreferredFrameRate_002
923  * @tc.desc: AVCdecList GetPreferredFrameRate for not supported size
924  * @tc.type: FUNC
925  * @tc.require:
926  */
927 HWTEST_F(CapsUnitTest, AVCaps_GetPreferredFrameRate_002, TestSize.Level1)
928 {
929     Range ret;
930     std::vector<std::shared_ptr<VideoCaps>> videoEncoderArray = GetVideoEncoderCaps();
931     for (auto iter = videoEncoderArray.begin(); iter != videoEncoderArray.end(); iter++) {
932         ret = (*iter)->GetPreferredFrameRate(DEFAULT_WIDTH_RANGE.maxVal + 1, DEFAULT_HEIGHT_RANGE.maxVal + 1);
933         EXPECT_GE(ret.minVal, 0);
934     }
935     std::vector<std::shared_ptr<VideoCaps>> videoDecoderArray = GetVideoDecoderCaps();
936     for (auto iter = videoDecoderArray.begin(); iter != videoDecoderArray.end(); iter++) {
937         ret = (*iter)->GetPreferredFrameRate(DEFAULT_WIDTH_RANGE.minVal - 1, DEFAULT_HEIGHT_RANGE.minVal - 1);
938         EXPECT_GE(ret.minVal, 0);
939     }
940 }
941 
942 #ifdef CODECLIST_CAPI_UNIT_TEST
943 
944 /**
945  * @tc.name: AVCaps_NullvalToCapi_001
946  * @tc.desc: AVCdecList GetCapi for not null val
947  * @tc.type: FUNC
948  * @tc.require:
949  */
950 HWTEST_F(CapsUnitTest, AVCaps_NullvalToCapi_001, TestSize.Level1)
951 {
952     EXPECT_EQ(OH_AVCapability_IsHardware(nullptr), false);
953 
954     EXPECT_STREQ(OH_AVCapability_GetName(nullptr), "");
955 
956     EXPECT_EQ(OH_AVCapability_GetMaxSupportedInstances(nullptr), 0);
957 
958     const int32_t *sampleRates = nullptr;
959     uint32_t sampleRateNum = 0;
960     EXPECT_EQ(OH_AVCapability_GetAudioSupportedSampleRates(nullptr, &sampleRates, &sampleRateNum), AV_ERR_INVALID_VAL);
961     EXPECT_EQ(sampleRates, nullptr);
962     EXPECT_EQ(sampleRateNum, 0);
963 
964     EXPECT_EQ(OH_AVCapability_IsVideoSizeSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT), false);
965 
966     EXPECT_EQ(
967         OH_AVCapability_AreVideoSizeAndFrameRateSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FRAMERATE),
968         false);
969 
970     const int32_t *pixFormats = nullptr;
971     uint32_t pixFormatNum = -1;
972     EXPECT_EQ(OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixFormats, &pixFormatNum), AV_ERR_INVALID_VAL);
973     EXPECT_EQ(pixFormats, nullptr);
974     EXPECT_EQ(pixFormatNum, 0);
975 
976     const int32_t *profiles = nullptr;
977     uint32_t profileNum = -1;
978     EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(nullptr, &profiles, &profileNum), AV_ERR_INVALID_VAL);
979     EXPECT_EQ(profiles, nullptr);
980     EXPECT_EQ(profileNum, 0);
981 
982     const int32_t *levels = nullptr;
983     uint32_t levelNum = -1;
984     EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(nullptr, DEFAULT_VIDEO_AVC_PROFILE, &levels, &levelNum),
985               AV_ERR_INVALID_VAL);
986     EXPECT_EQ(levels, nullptr);
987     EXPECT_EQ(levelNum, 0);
988 
989     EXPECT_EQ(OH_AVCapability_AreProfileAndLevelSupported(nullptr, DEFAULT_VIDEO_AVC_PROFILE, AVC_LEVEL_1), false);
990 }
991 
992 /**
993  * @tc.name: AVCaps_NullvalToCapi_002
994  * @tc.desc: AVCdecList GetCapi for not null val
995  * @tc.type: FUNC
996  * @tc.require:
997  */
998 HWTEST_F(CapsUnitTest, AVCaps_NullvalToCapi_002, TestSize.Level1)
999 {
1000     OH_AVRange range = {-1, -1};
1001     EXPECT_EQ(OH_AVCapability_GetEncoderBitrateRange(nullptr, &range), AV_ERR_INVALID_VAL);
1002     EXPECT_EQ(range.minVal, 0);
1003     EXPECT_EQ(range.maxVal, 0);
1004 
1005     range = {-1, -1};
1006     EXPECT_EQ(OH_AVCapability_GetEncoderQualityRange(nullptr, &range), AV_ERR_INVALID_VAL);
1007     EXPECT_EQ(range.minVal, 0);
1008     EXPECT_EQ(range.maxVal, 0);
1009 
1010     range = {-1, -1};
1011     EXPECT_EQ(OH_AVCapability_GetEncoderComplexityRange(nullptr, &range), AV_ERR_INVALID_VAL);
1012     EXPECT_EQ(range.minVal, 0);
1013     EXPECT_EQ(range.maxVal, 0);
1014 
1015     range = {-1, -1};
1016     EXPECT_EQ(OH_AVCapability_GetAudioChannelCountRange(nullptr, &range), AV_ERR_INVALID_VAL);
1017     EXPECT_EQ(range.minVal, 0);
1018     EXPECT_EQ(range.maxVal, 0);
1019 
1020     range = {-1, -1};
1021     EXPECT_EQ(OH_AVCapability_GetVideoWidthRangeForHeight(nullptr, DEFAULT_HEIGHT, &range), AV_ERR_INVALID_VAL);
1022     EXPECT_EQ(range.minVal, 0);
1023     EXPECT_EQ(range.maxVal, 0);
1024 
1025     range = {-1, -1};
1026     EXPECT_EQ(OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, DEFAULT_WIDTH, &range), AV_ERR_INVALID_VAL);
1027     EXPECT_EQ(range.minVal, 0);
1028     EXPECT_EQ(range.maxVal, 0);
1029 
1030     range = {-1, -1};
1031     EXPECT_EQ(OH_AVCapability_GetVideoWidthRange(nullptr, &range), AV_ERR_INVALID_VAL);
1032     EXPECT_EQ(range.minVal, 0);
1033     EXPECT_EQ(range.maxVal, 0);
1034 
1035     range = {-1, -1};
1036     EXPECT_EQ(OH_AVCapability_GetVideoHeightRange(nullptr, &range), AV_ERR_INVALID_VAL);
1037     EXPECT_EQ(range.minVal, 0);
1038     EXPECT_EQ(range.maxVal, 0);
1039 
1040     range = {-1, -1};
1041     EXPECT_EQ(OH_AVCapability_GetVideoFrameRateRange(nullptr, &range), AV_ERR_INVALID_VAL);
1042     EXPECT_EQ(range.minVal, 0);
1043     EXPECT_EQ(range.maxVal, 0);
1044 
1045     range = {-1, -1};
1046     EXPECT_EQ(OH_AVCapability_GetVideoFrameRateRangeForSize(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range),
1047               AV_ERR_INVALID_VAL);
1048     EXPECT_EQ(range.minVal, 0);
1049     EXPECT_EQ(range.maxVal, 0);
1050 }
1051 
1052 /**
1053  * @tc.name: AVCaps_FeatureCheck_001
1054  * @tc.desc: AVCaps feature check, valid input
1055  * @tc.type: FUNC
1056  * @tc.require:
1057  */
1058 HWTEST_F(CapsUnitTest, AVCaps_FeatureCheck_001, TestSize.Level1)
1059 {
1060     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1061     EXPECT_NE(cap, nullptr);
1062     std::string nameStr = OH_AVCapability_GetName(cap);
1063     std::string mimeStr = OH_AVCODEC_MIMETYPE_VIDEO_AVC;
1064     auto it = CAPABILITY_ENCODER_HARD_NAME.find(mimeStr);
1065     if (it != CAPABILITY_ENCODER_HARD_NAME.end()) {
1066         if (nameStr.compare(it->second) == 0) {
1067             EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, VIDEO_ENCODER_TEMPORAL_SCALABILITY), true);
1068             EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, VIDEO_ENCODER_LONG_TERM_REFERENCE), true);
1069             EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, VIDEO_LOW_LATENCY), true);
1070         } else {
1071             EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, VIDEO_ENCODER_TEMPORAL_SCALABILITY), false);
1072             EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, VIDEO_ENCODER_LONG_TERM_REFERENCE), false);
1073             EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, VIDEO_LOW_LATENCY), false);
1074         }
1075     }
1076 }
1077 
1078 /**
1079  * @tc.name: AVCaps_FeatureCheck_002
1080  * @tc.desc: AVCaps feature check, invalid input
1081  * @tc.type: FUNC
1082  * @tc.require:
1083  */
1084 HWTEST_F(CapsUnitTest, AVCaps_FeatureCheck_002, TestSize.Level1)
1085 {
1086     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1087     EXPECT_NE(cap, nullptr);
1088     EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, static_cast<OH_AVCapabilityFeature>(-1)), false);
1089     EXPECT_EQ(OH_AVCapability_IsFeatureSupported(cap, static_cast<OH_AVCapabilityFeature>(4)), false);
1090 }
1091 
1092 /**
1093  * @tc.name: AVCaps_FeatureProperties_001
1094  * @tc.desc: AVCaps query feature with properties
1095  * @tc.type: FUNC
1096  * @tc.require:
1097  */
1098 HWTEST_F(CapsUnitTest, AVCaps_FeatureProperties_001, TestSize.Level1)
1099 {
1100     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1101     EXPECT_NE(cap, nullptr);
1102     std::string nameStr = OH_AVCapability_GetName(cap);
1103     std::string mimeStr = OH_AVCODEC_MIMETYPE_VIDEO_AVC;
1104     auto it = CAPABILITY_ENCODER_HARD_NAME.find(mimeStr);
1105     if (it != CAPABILITY_ENCODER_HARD_NAME.end()) {
1106         if (nameStr.compare(it->second) == 0) {
1107             OH_AVFormat *property = OH_AVCapability_GetFeatureProperties(cap, VIDEO_ENCODER_LONG_TERM_REFERENCE);
1108             EXPECT_NE(property, nullptr);
1109             int ltrNum = 0;
1110             EXPECT_EQ(OH_AVFormat_GetIntValue(
1111                 property, OH_FEATURE_PROPERTY_KEY_VIDEO_ENCODER_MAX_LTR_FRAME_COUNT, &ltrNum), true);
1112             EXPECT_GT(ltrNum, 0);
1113             OH_AVFormat_Destroy(property);
1114         } else {
1115             OH_AVFormat *property = OH_AVCapability_GetFeatureProperties(cap, VIDEO_ENCODER_LONG_TERM_REFERENCE);
1116             EXPECT_EQ(property, nullptr);
1117         }
1118     }
1119 }
1120 
1121 /**
1122  * @tc.name: AVCaps_FeatureProperties_002
1123  * @tc.desc: AVCaps query feature without properties
1124  * @tc.type: FUNC
1125  * @tc.require:
1126  */
1127 HWTEST_F(CapsUnitTest, AVCaps_FeatureProperties_002, TestSize.Level1)
1128 {
1129     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1130     EXPECT_NE(cap, nullptr);
1131     OH_AVFormat *property = OH_AVCapability_GetFeatureProperties(cap, VIDEO_ENCODER_TEMPORAL_SCALABILITY);
1132     EXPECT_EQ(property, nullptr);
1133 }
1134 
1135 /**
1136  * @tc.name: AVCaps_FeatureProperties_003
1137  * @tc.desc: AVCaps query unspported feature properties
1138  * @tc.type: FUNC
1139  * @tc.require:
1140  */
1141 HWTEST_F(CapsUnitTest, AVCaps_FeatureProperties_003, TestSize.Level1)
1142 {
1143     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1144     EXPECT_NE(cap, nullptr);
1145     OH_AVFormat *property = OH_AVCapability_GetFeatureProperties(cap, VIDEO_LOW_LATENCY);
1146     EXPECT_EQ(property, nullptr);
1147 }
1148 
1149 /**
1150  * @tc.name: AVCaps_FeatureProperties_004
1151  * @tc.desc: AVCaps query unspported feature properties
1152  * @tc.type: FUNC
1153  * @tc.require:
1154  */
1155 HWTEST_F(CapsUnitTest, AVCaps_FeatureProperties_004, TestSize.Level1)
1156 {
1157     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
1158     EXPECT_NE(cap, nullptr);
1159     OH_AVFormat *property = OH_AVCapability_GetFeatureProperties(cap, VIDEO_ENCODER_B_FRAME);
1160     EXPECT_EQ(property, nullptr);
1161 }
1162 
1163 /**
1164  * @tc.name: AVCaps_Levels_001
1165  * @tc.desc: AVCaps query H264 hw decoder supported levels for baseline\main\high profile
1166  * @tc.type: FUNC
1167  * @tc.require:
1168  */
1169 HWTEST_F(CapsUnitTest, AVCaps_Levels_001, TestSize.Level1)
1170 {
1171     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1172     EXPECT_NE(cap, nullptr);
1173     const int32_t *profiles = nullptr;
1174     uint32_t profilesNum = -1;
1175     EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(cap, &profiles, &profilesNum), AV_ERR_OK);
1176     EXPECT_GT(profilesNum, 0);
1177     for (int32_t i = 0; i < profilesNum; i++) {
1178         int32_t profile = profiles[i];
1179         EXPECT_GE(profile, AVC_PROFILE_BASELINE);
1180         EXPECT_LE(profile, AVC_PROFILE_MAIN);
1181         const int32_t *levels = nullptr;
1182         uint32_t levelsNum = -1;
1183         EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(cap, profile, &levels, &levelsNum), AV_ERR_OK);
1184         EXPECT_GT(levelsNum, 0);
1185         EXPECT_LE(levelsNum, AVC_LEVEL_62 + 1);
1186         for (int32_t j = 0; j < levelsNum; j++) {
1187             int32_t level = levels[j];
1188             EXPECT_GE(level, AVC_LEVEL_1);
1189             EXPECT_LE(level, AVC_LEVEL_62);
1190         }
1191     }
1192 }
1193 
1194 /**
1195  * @tc.name: AVCaps_Levels_002
1196  * @tc.desc: AVCaps query H265 hw decoder supported levels for main\main10 profile
1197  * @tc.type: FUNC
1198  * @tc.require:
1199  */
1200 HWTEST_F(CapsUnitTest, AVCaps_Levels_002, TestSize.Level1)
1201 {
1202     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1203     EXPECT_NE(cap, nullptr);
1204     const int32_t *profiles = nullptr;
1205     uint32_t profilesNum = -1;
1206     EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(cap, &profiles, &profilesNum), AV_ERR_OK);
1207     EXPECT_GT(profilesNum, 0);
1208     for (int32_t i = 0; i < profilesNum; i++) {
1209         int32_t profile = profiles[i];
1210         EXPECT_GE(profile, HEVC_PROFILE_MAIN);
1211         EXPECT_LE(profile, HEVC_PROFILE_MAIN_10_HDR10_PLUS);
1212         const int32_t *levels = nullptr;
1213         uint32_t levelsNum = -1;
1214         EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(cap, profile, &levels, &levelsNum), AV_ERR_OK);
1215         EXPECT_GT(levelsNum, 0);
1216         EXPECT_LE(levelsNum, HEVC_LEVEL_62 + 1);
1217         for (int32_t j = 0; j < levelsNum; j++) {
1218             int32_t level = levels[j];
1219             EXPECT_GE(level, HEVC_LEVEL_1);
1220             EXPECT_LE(level, HEVC_LEVEL_62);
1221         }
1222     }
1223 }
1224 
1225 /**
1226  * @tc.name: AVCaps_Levels_003
1227  * @tc.desc: AVCaps query H264 hw encoder supported levels for baseline\main\high profile
1228  * @tc.type: FUNC
1229  * @tc.require:
1230  */
1231 HWTEST_F(CapsUnitTest, AVCaps_Levels_003, TestSize.Level1)
1232 {
1233     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1234     EXPECT_NE(cap, nullptr);
1235     const int32_t *profiles = nullptr;
1236     uint32_t profilesNum = -1;
1237     EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(cap, &profiles, &profilesNum), AV_ERR_OK);
1238     EXPECT_GT(profilesNum, 0);
1239     for (int32_t i = 0; i < profilesNum; i++) {
1240         int32_t profile = profiles[i];
1241         EXPECT_GE(profile, AVC_PROFILE_BASELINE);
1242         EXPECT_LE(profile, AVC_PROFILE_MAIN);
1243         const int32_t *levels = nullptr;
1244         uint32_t levelsNum = -1;
1245         EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(cap, profile, &levels, &levelsNum), AV_ERR_OK);
1246         EXPECT_GT(levelsNum, 0);
1247         EXPECT_LE(levelsNum, AVC_LEVEL_62 + 1);
1248         for (int32_t j = 0; j < levelsNum; j++) {
1249             int32_t level = levels[j];
1250             EXPECT_GE(level, AVC_LEVEL_1);
1251             EXPECT_LE(level, AVC_LEVEL_62);
1252         }
1253     }
1254 }
1255 
1256 /**
1257  * @tc.name: AVCaps_Levels_004
1258  * @tc.desc: AVCaps query H265 hw encoder supported levels for main\main10 profile
1259  * @tc.type: FUNC
1260  * @tc.require:
1261  */
1262 HWTEST_F(CapsUnitTest, AVCaps_Levels_004, TestSize.Level1)
1263 {
1264     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
1265     EXPECT_NE(cap, nullptr);
1266     const int32_t *profiles = nullptr;
1267     uint32_t profilesNum = -1;
1268     EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(cap, &profiles, &profilesNum), AV_ERR_OK);
1269     EXPECT_GT(profilesNum, 0);
1270     for (int32_t i = 0; i < profilesNum; i++) {
1271         int32_t profile = profiles[i];
1272         EXPECT_GE(profile, HEVC_PROFILE_MAIN);
1273         EXPECT_LE(profile, HEVC_PROFILE_MAIN_10_HDR10_PLUS);
1274         const int32_t *levels = nullptr;
1275         uint32_t levelsNum = -1;
1276         EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(cap, profile, &levels, &levelsNum), AV_ERR_OK);
1277         EXPECT_GT(levelsNum, 0);
1278         EXPECT_LE(levelsNum, HEVC_LEVEL_62 + 1);
1279         for (int32_t j = 0; j < levelsNum; j++) {
1280             int32_t level = levels[j];
1281             EXPECT_GE(level, HEVC_LEVEL_1);
1282             EXPECT_LE(level, HEVC_LEVEL_62);
1283         }
1284     }
1285 }
1286 
1287 /**
1288  * @tc.name: AVCaps_Levels_005
1289  * @tc.desc: AVCaps query H264 sw decoder supported levels for baseline\main\high profile
1290  * @tc.type: FUNC
1291  * @tc.require:
1292  */
1293 HWTEST_F(CapsUnitTest, AVCaps_Levels_005, TestSize.Level1)
1294 {
1295     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1296     EXPECT_NE(cap, nullptr);
1297     const int32_t *profiles = nullptr;
1298     uint32_t profilesNum = -1;
1299     EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(cap, &profiles, &profilesNum), AV_ERR_OK);
1300     EXPECT_GT(profilesNum, 0);
1301     for (int32_t i = 0; i < profilesNum; i++) {
1302         int32_t profile = profiles[i];
1303         EXPECT_GE(profile, AVC_PROFILE_BASELINE);
1304         EXPECT_LE(profile, AVC_PROFILE_MAIN);
1305         const int32_t *levels = nullptr;
1306         uint32_t levelsNum = -1;
1307         EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(cap, profile, &levels, &levelsNum), AV_ERR_OK);
1308         EXPECT_GT(levelsNum, 0);
1309         EXPECT_LE(levelsNum, AVC_LEVEL_62 + 1);
1310         for (int32_t j = 0; j < levelsNum; j++) {
1311             int32_t level = levels[j];
1312             EXPECT_GE(level, AVC_LEVEL_1);
1313             EXPECT_LE(level, AVC_LEVEL_62);
1314         }
1315     }
1316 }
1317 
1318 /**
1319  * @tc.name: AVCaps_MixedUse_001
1320  * @tc.desc: AVCaps mixed use cap, video cap to get audio info
1321  * @tc.type: FUNC
1322  * @tc.require:
1323  */
1324 HWTEST_F(CapsUnitTest, AVCaps_MixedUse_001, TestSize.Level1)
1325 {
1326     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1327     EXPECT_NE(cap, nullptr);
1328     OH_AVRange range = {-1, -1};
1329     EXPECT_EQ(OH_AVCapability_GetAudioChannelCountRange(cap, &range), AV_ERR_OK);
1330 }
1331 
1332 /**
1333  * @tc.name: AVCaps_MixedUse_002
1334  * @tc.desc: AVCaps mixed use cap, audio cap to get video info
1335  * @tc.type: FUNC
1336  * @tc.require:
1337  */
1338 HWTEST_F(CapsUnitTest, AVCaps_MixedUse_002, TestSize.Level1)
1339 {
1340     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_AUDIO_AAC, false, SOFTWARE);
1341     EXPECT_NE(cap, nullptr);
1342     OH_AVRange range = {-1, -1};
1343     EXPECT_EQ(OH_AVCapability_GetVideoWidthRange(cap, &range), AV_ERR_OK);
1344 }
1345 
1346 /**
1347  * @tc.name: AVCaps_MixedUse_003
1348  * @tc.desc: AVCaps mixed use cap, decoder cap to get encoder info
1349  * @tc.type: FUNC
1350  * @tc.require:
1351  */
1352 HWTEST_F(CapsUnitTest, AVCaps_MixedUse_003, TestSize.Level1)
1353 {
1354     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1355     EXPECT_NE(cap, nullptr);
1356     OH_AVRange range = {-1, -1};
1357     EXPECT_EQ(OH_AVCapability_GetEncoderQualityRange(cap, &range), AV_ERR_OK);
1358 }
1359 
1360 HWTEST_F(CapsUnitTest, AVCaps_THREAD_POOL_001, TestSize.Level2)
1361 {
1362     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1363     EXPECT_NE(cap, nullptr);
1364     const int threadCnt = 10;
1365     std::vector<std::thread> threadPool;
1366     for (int32_t i = 0; i < threadCnt; i++) {
__anona444f92a0102() 1367         threadPool.emplace_back([&cap]() {
1368             const int32_t *profiles = nullptr;
1369             uint32_t profilesNum = -1;
1370             EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(cap, &profiles, &profilesNum), AV_ERR_OK);
1371             EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(cap, &profiles, &profilesNum), AV_ERR_OK);
1372             EXPECT_EQ(OH_AVCapability_GetSupportedProfiles(cap, &profiles, &profilesNum), AV_ERR_OK);
1373         });
1374     }
1375     for (auto &th : threadPool) {
1376         th.join();
1377     }
1378 }
1379 
1380 HWTEST_F(CapsUnitTest, AVCaps_THREAD_POOL_002, TestSize.Level2)
1381 {
1382     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1383     EXPECT_NE(cap, nullptr);
1384     const int threadCnt = 10;
1385     std::vector<std::thread> threadPool;
1386     for (int32_t i = 0; i < threadCnt; i++) {
__anona444f92a0202() 1387         threadPool.emplace_back([&cap]() {
1388             const int32_t *levels = nullptr;
1389             uint32_t levelsNum = -1;
1390             int32_t profile = static_cast<int32_t>(AVC_PROFILE_BASELINE);
1391             EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(cap, profile, &levels, &levelsNum), AV_ERR_OK);
1392             EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(cap, profile, &levels, &levelsNum), AV_ERR_OK);
1393             EXPECT_EQ(OH_AVCapability_GetSupportedLevelsForProfile(cap, profile, &levels, &levelsNum), AV_ERR_OK);
1394         });
1395     }
1396     for (auto &th : threadPool) {
1397         th.join();
1398     }
1399 }
1400 
1401 HWTEST_F(CapsUnitTest, AVCaps_THREAD_POOL_003, TestSize.Level2)
1402 {
1403     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1404     EXPECT_NE(cap, nullptr);
1405     const int threadCnt = 10;
1406     std::vector<std::thread> threadPool;
1407     for (int32_t i = 0; i < threadCnt; i++) {
__anona444f92a0302() 1408         threadPool.emplace_back([&cap]() {
1409             const int32_t *sampleRates = nullptr;
1410             uint32_t sampleRateNum = 0;
1411             EXPECT_EQ(OH_AVCapability_GetAudioSupportedSampleRates(cap, &sampleRates, &sampleRateNum), AV_ERR_OK);
1412             EXPECT_EQ(OH_AVCapability_GetAudioSupportedSampleRates(cap, &sampleRates, &sampleRateNum), AV_ERR_OK);
1413             EXPECT_EQ(OH_AVCapability_GetAudioSupportedSampleRates(cap, &sampleRates, &sampleRateNum), AV_ERR_OK);
1414         });
1415     }
1416     for (auto &th : threadPool) {
1417         th.join();
1418     }
1419 }
1420 
1421 HWTEST_F(CapsUnitTest, AVCaps_THREAD_POOL_004, TestSize.Level2)
1422 {
1423     OH_AVCapability *cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1424     EXPECT_NE(cap, nullptr);
1425     const int threadCnt = 10;
1426     std::vector<std::thread> threadPool;
1427     for (int32_t i = 0; i < threadCnt; i++) {
__anona444f92a0402() 1428         threadPool.emplace_back([&cap]() {
1429             const int32_t *pixFormats = nullptr;
1430             uint32_t pixFormatNum = -1;
1431             EXPECT_EQ(OH_AVCapability_GetVideoSupportedPixelFormats(cap, &pixFormats, &pixFormatNum), AV_ERR_OK);
1432             EXPECT_EQ(OH_AVCapability_GetVideoSupportedPixelFormats(cap, &pixFormats, &pixFormatNum), AV_ERR_OK);
1433             EXPECT_EQ(OH_AVCapability_GetVideoSupportedPixelFormats(cap, &pixFormats, &pixFormatNum), AV_ERR_OK);
1434         });
1435     }
1436     for (auto &th : threadPool) {
1437         th.join();
1438     }
1439 }
1440 #endif
1441 } // namespace MediaAVCodec
1442 } // namespace OHOS
1443