1 /* 2 * Copyright (C) 2024 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 #include <string> 16 #include <securec.h> 17 #include "gtest/gtest.h" 18 #include "native_avcodec_audiocodec.h" 19 #include "native_averrors.h" 20 #include "native_avcodec_base.h" 21 #include "native_avcapability.h" 22 23 using namespace std; 24 using namespace testing::ext; 25 26 namespace { 27 class AudioCapabilityTest : public testing::Test { 28 public: 29 static void SetUpTestCase(); 30 static void TearDownTestCase(); 31 void SetUp() override; 32 void TearDown() override; 33 }; 34 SetUpTestCase()35 void AudioCapabilityTest::SetUpTestCase() {} TearDownTestCase()36 void AudioCapabilityTest::TearDownTestCase() {} SetUp()37 void AudioCapabilityTest::SetUp() {} TearDown()38 void AudioCapabilityTest::TearDown() {} 39 CheckSampleRate(int32_t * sampleRateList,uint32_t sampleRateNum,OH_AVRange * sampleRateRanges,uint32_t rangesNum)40 bool CheckSampleRate(int32_t* sampleRateList, uint32_t sampleRateNum, OH_AVRange* sampleRateRanges, 41 uint32_t rangesNum) 42 { 43 bool inFlags = false; 44 for (uint32_t i = 0; i < sampleRateNum; i++) { 45 for (uint32_t j = 0; j < rangesNum; j++) { 46 if (sampleRateList[i] >= sampleRateRanges[j].minVal && 47 sampleRateList[i] <= sampleRateRanges[j].maxVal) { 48 inFlags = true; 49 break; 50 } 51 } 52 if (!inFlags) { 53 return false; 54 } 55 } 56 return true; 57 } 58 59 } // namespace 60 61 /** 62 * @tc.number : AUDIO_CAPABILITY_TEST_001 63 * @tc.name : AUDIO_CAPABILITY_TEST_001 64 * @tc.desc : function test 65 */ 66 HWTEST_F(AudioCapabilityTest, AUDIO_CAPABILITY_TEST_001, TestSize.Level2) 67 { 68 OH_AVCapability* capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_AAC, true); 69 ASSERT_NE(capability, nullptr); 70 int32_t sampleRateList[] = { 7350, 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 71 48000, 64000, 88200, 96000 }; 72 uint32_t sampleRateNum = 13; 73 OH_AVRange* sampleRateRanges = nullptr; 74 uint32_t rangesNum = -1; 75 OH_AVErrCode ret = OH_AVCapability_GetAudioSupportedSampleRateRanges(capability, &sampleRateRanges, &rangesNum); 76 ASSERT_EQ(ret, AV_ERR_OK); 77 bool result = CheckSampleRate(sampleRateList, sampleRateNum, sampleRateRanges, rangesNum); 78 ASSERT_EQ(result, true); 79 } 80 81 82 /** 83 * @tc.number : AUDIO_CAPABILITY_TEST_002 84 * @tc.name : AUDIO_CAPABILITY_TEST_002 85 * @tc.desc : function test 86 */ 87 HWTEST_F(AudioCapabilityTest, AUDIO_CAPABILITY_TEST_002, TestSize.Level2) 88 { 89 OH_AVCapability* capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_AAC, false); 90 ASSERT_NE(capability, nullptr); 91 int32_t sampleRateList[] = { 7350, 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 92 48000, 64000, 88200, 96000 }; 93 uint32_t sampleRateNum = 13; 94 OH_AVRange* sampleRateRanges = nullptr; 95 uint32_t rangesNum = -1; 96 OH_AVErrCode ret = OH_AVCapability_GetAudioSupportedSampleRateRanges(capability, &sampleRateRanges, &rangesNum); 97 ASSERT_EQ(ret, AV_ERR_OK); 98 bool result = CheckSampleRate(sampleRateList, sampleRateNum, sampleRateRanges, rangesNum); 99 ASSERT_EQ(result, true); 100 } 101 102 103 /** 104 * @tc.number : AUDIO_CAPABILITY_TEST_003 105 * @tc.name : AUDIO_CAPABILITY_TEST_003 106 * @tc.desc : function test 107 */ 108 HWTEST_F(AudioCapabilityTest, AUDIO_CAPABILITY_TEST_003, TestSize.Level2) 109 { 110 OH_AVCapability* capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, true); 111 ASSERT_NE(capability, nullptr); 112 int32_t sampleRateList[] = { 8000, 16000, 22050, 24000, 32000, 44100, 48000, 88200, 96000 }; 113 uint32_t sampleRateNum = 9; 114 OH_AVRange* sampleRateRanges = nullptr; 115 uint32_t rangesNum = -1; 116 OH_AVErrCode ret = OH_AVCapability_GetAudioSupportedSampleRateRanges(capability, &sampleRateRanges, &rangesNum); 117 ASSERT_EQ(ret, AV_ERR_OK); 118 bool result = CheckSampleRate(sampleRateList, sampleRateNum, sampleRateRanges, rangesNum); 119 ASSERT_EQ(result, true); 120 } 121 122 123 /** 124 * @tc.number : AUDIO_CAPABILITY_TEST_004 125 * @tc.name : AUDIO_CAPABILITY_TEST_004 126 * @tc.desc : function test 127 */ 128 HWTEST_F(AudioCapabilityTest, AUDIO_CAPABILITY_TEST_004, TestSize.Level2) 129 { 130 OH_AVCapability* capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_FLAC, false); 131 ASSERT_NE(capability, nullptr); 132 int32_t sampleRateList[] = { 8000, 384000 }; 133 uint32_t sampleRateNum = 2; 134 OH_AVRange* sampleRateRanges = nullptr; 135 uint32_t rangesNum = -1; 136 OH_AVErrCode ret = OH_AVCapability_GetAudioSupportedSampleRateRanges(capability, &sampleRateRanges, &rangesNum); 137 ASSERT_EQ(ret, AV_ERR_OK); 138 bool result = CheckSampleRate(sampleRateList, sampleRateNum, sampleRateRanges, rangesNum); 139 ASSERT_EQ(result, true); 140 } 141 142 143 /** 144 * @tc.number : AUDIO_CAPABILITY_TEST_005 145 * @tc.name : AUDIO_CAPABILITY_TEST_005 146 * @tc.desc : function test 147 */ 148 HWTEST_F(AudioCapabilityTest, AUDIO_CAPABILITY_TEST_005, TestSize.Level2) 149 { 150 OH_AVCapability* capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_VORBIS, false); 151 ASSERT_NE(capability, nullptr); 152 int32_t sampleRateList[] = { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000 }; 153 uint32_t sampleRateNum = 12; 154 OH_AVRange* sampleRateRanges = nullptr; 155 uint32_t rangesNum = -1; 156 OH_AVErrCode ret = OH_AVCapability_GetAudioSupportedSampleRateRanges(capability, &sampleRateRanges, &rangesNum); 157 ASSERT_EQ(ret, AV_ERR_OK); 158 bool result = CheckSampleRate(sampleRateList, sampleRateNum, sampleRateRanges, rangesNum); 159 ASSERT_EQ(result, true); 160 } 161 162 163 /** 164 * @tc.number : AUDIO_CAPABILITY_TEST_006 165 * @tc.name : AUDIO_CAPABILITY_TEST_006 166 * @tc.desc : function test 167 */ 168 HWTEST_F(AudioCapabilityTest, AUDIO_CAPABILITY_TEST_006, TestSize.Level2) 169 { 170 OH_AVCapability* capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, true); 171 ASSERT_NE(capability, nullptr); 172 int32_t sampleRateList[] = { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }; 173 uint32_t sampleRateNum = 9; 174 OH_AVRange* sampleRateRanges = nullptr; 175 uint32_t rangesNum = -1; 176 OH_AVErrCode ret = OH_AVCapability_GetAudioSupportedSampleRateRanges(capability, &sampleRateRanges, &rangesNum); 177 ASSERT_EQ(ret, AV_ERR_OK); 178 bool result = CheckSampleRate(sampleRateList, sampleRateNum, sampleRateRanges, rangesNum); 179 ASSERT_EQ(result, true); 180 } 181 182 183 /** 184 * @tc.number : AUDIO_CAPABILITY_TEST_007 185 * @tc.name : AUDIO_CAPABILITY_TEST_007 186 * @tc.desc : function test 187 */ 188 HWTEST_F(AudioCapabilityTest, AUDIO_CAPABILITY_TEST_007, TestSize.Level2) 189 { 190 OH_AVCapability* capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_AUDIO_MPEG, false); 191 ASSERT_NE(capability, nullptr); 192 int32_t sampleRateList[] = { 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }; 193 uint32_t sampleRateNum = 9; 194 OH_AVRange* sampleRateRanges = nullptr; 195 uint32_t rangesNum = -1; 196 OH_AVErrCode ret = OH_AVCapability_GetAudioSupportedSampleRateRanges(capability, &sampleRateRanges, &rangesNum); 197 ASSERT_EQ(ret, AV_ERR_OK); 198 bool result = CheckSampleRate(sampleRateList, sampleRateNum, sampleRateRanges, rangesNum); 199 ASSERT_EQ(result, true); 200 }