1 /* 2 * Copyright (c) 2021-2021 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 <gtest/gtest.h> 17 18 #define private public 19 #define protected public 20 #define UNIT_TEST 1 21 #include "foundation/utils/constants.h" 22 #include "pipeline/core/compatible_check.h" 23 #include "plugin/common/any.h" 24 #include "plugin/common/plugin_audio_tags.h" 25 #include "plugin/common/plugin_meta.h" 26 27 using namespace testing::ext; 28 29 using namespace std; 30 using namespace OHOS::Media::Plugin; 31 32 namespace OHOS::Media::Test { 33 HWTEST(TestApplyCapability, mime_Test, TestSize.Level1) 34 { 35 Capability wildcard {"*"}; 36 Capability audioWildcard {"audio/*"}; 37 Capability testWildcard {"test/*"}; 38 Capability wrongWildcard {"/audio*"}; 39 Capability wrongCapability {"wrong"}; 40 Capability rawMimeCapability {"audio/raw"}; 41 Capability mpegMimeCapability {"audio/mpeg"}; 42 43 Capability out; 44 ASSERT_TRUE(Pipeline::MergeCapability(audioWildcard, wildcard, out)); 45 ASSERT_TRUE(out.mime == audioWildcard.mime); 46 ASSERT_TRUE(out.keys.empty()); 47 48 ASSERT_FALSE(Pipeline::MergeCapability(wrongWildcard, wildcard, out)); 49 ASSERT_TRUE(out.mime.empty()); 50 ASSERT_TRUE(out.keys.empty()); 51 52 ASSERT_FALSE(Pipeline::MergeCapability(wrongCapability, wildcard, out)); 53 ASSERT_TRUE(out.mime.empty()); 54 ASSERT_TRUE(out.keys.empty()); 55 56 ASSERT_FALSE(Pipeline::MergeCapability(wrongCapability, audioWildcard, out)); 57 ASSERT_TRUE(out.mime.empty()); 58 ASSERT_TRUE(out.keys.empty()); 59 60 61 ASSERT_TRUE(Pipeline::MergeCapability(rawMimeCapability, wildcard, out)); 62 ASSERT_TRUE(out.mime == rawMimeCapability.mime); 63 ASSERT_TRUE(out.keys.empty()); 64 65 ASSERT_TRUE(Pipeline::MergeCapability(rawMimeCapability, audioWildcard, out)); 66 ASSERT_TRUE(out.mime == rawMimeCapability.mime); 67 ASSERT_TRUE(out.keys.empty()); 68 69 ASSERT_FALSE(Pipeline::MergeCapability(rawMimeCapability, testWildcard, out)); 70 ASSERT_TRUE(out.mime.empty()); 71 ASSERT_TRUE(out.keys.empty()); 72 73 ASSERT_FALSE(Pipeline::MergeCapability(rawMimeCapability, mpegMimeCapability, out)); 74 ASSERT_TRUE(out.mime.empty()); 75 ASSERT_TRUE(out.keys.empty()); 76 77 ASSERT_FALSE(Pipeline::MergeCapability(rawMimeCapability, wrongWildcard, out)); 78 ASSERT_TRUE(out.mime.empty()); 79 ASSERT_TRUE(out.keys.empty()); 80 } 81 82 HWTEST(TestMergeCapabilityKeys, SingleType1_Test, TestSize.Level1) 83 { 84 Capability wildMimeCapability("*"); 85 Capability out; 86 87 Capability rawFixedMimeCapability (MEDIA_MIME_AUDIO_RAW); 88 rawFixedMimeCapability.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000); 89 90 ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawFixedMimeCapability, wildMimeCapability, out)); 91 ASSERT_TRUE(out.mime.empty()); 92 ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000); 93 94 Capability rawFixedMimeCapability2 (MEDIA_MIME_AUDIO_MPEG); 95 rawFixedMimeCapability2.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000); 96 97 // fix apply with fix 98 ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawFixedMimeCapability, rawFixedMimeCapability2, out)); 99 ASSERT_TRUE(out.mime.empty()); 100 ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000); 101 102 // apply failed 103 Capability rawFixedMimeCapability3 (MEDIA_MIME_AUDIO_RAW); 104 rawFixedMimeCapability3.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 4000); 105 ASSERT_FALSE(Pipeline::MergeCapabilityKeys(rawFixedMimeCapability, rawFixedMimeCapability3, out)); 106 ASSERT_TRUE(out.mime.empty()); 107 ASSERT_TRUE(out.keys.empty()); 108 109 Capability rawListMimeCapability {MEDIA_MIME_AUDIO_RAW}; 110 rawListMimeCapability.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {8000, 32000, 48000, 44100}); 111 112 ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawListMimeCapability, wildMimeCapability, out)); 113 ASSERT_TRUE(out.mime.empty()); 114 auto disCaps = Plugin::AnyCast<Plugin::DiscreteCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 115 ASSERT_TRUE(disCaps[0] == 8000); 116 ASSERT_TRUE(disCaps[1] == 32000); 117 ASSERT_TRUE(disCaps[2] == 48000); 118 ASSERT_TRUE(disCaps[3] == 44100); 119 120 // fix apply with discrete 121 ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawFixedMimeCapability, rawListMimeCapability, out)); 122 ASSERT_TRUE(out.mime.empty()); 123 ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000); 124 125 // apply failed 126 Capability rawFixedMimeCapability4 (MEDIA_MIME_AUDIO_RAW); 127 rawFixedMimeCapability4.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 4000); 128 ASSERT_FALSE(Pipeline::MergeCapabilityKeys(rawFixedMimeCapability4, rawListMimeCapability, out)); 129 ASSERT_TRUE(out.mime.empty()); 130 ASSERT_TRUE(out.keys.empty()); 131 } 132 133 HWTEST(TestMergeCapabilityKeys, SingleType2_Test, TestSize.Level1) 134 { 135 Capability wildMimeCapability("*"); 136 Capability out; 137 Capability rawFixedMimeCapability (MEDIA_MIME_AUDIO_RAW); 138 rawFixedMimeCapability.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000); 139 Capability rawListMimeCapability {MEDIA_MIME_AUDIO_RAW}; 140 rawListMimeCapability.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {8000, 32000, 48000, 44100}); 141 // discrete apply with discrete 142 Capability rawListMimeCapability2 {MEDIA_MIME_AUDIO_RAW}; 143 rawListMimeCapability2.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 48000, 44100}); 144 ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawListMimeCapability2, rawListMimeCapability, out)); 145 ASSERT_TRUE(out.mime.empty()); 146 auto tmp1 = Plugin::AnyCast<Plugin::DiscreteCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 147 ASSERT_TRUE(tmp1.size() == 2); 148 ASSERT_TRUE(tmp1[0] == 48000); 149 ASSERT_TRUE(tmp1[1] == 44100); 150 // discrete apply with discrete 151 Capability rawListMimeCapability3 {MEDIA_MIME_AUDIO_RAW}; 152 rawListMimeCapability3.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 44100}); 153 ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawListMimeCapability3, rawListMimeCapability, out)); 154 ASSERT_TRUE(out.mime.empty()); 155 auto tmp2 = Plugin::AnyCast<Plugin::FixedCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 156 ASSERT_TRUE(tmp2 == 44100); 157 // discrete apply with discrete failed 158 Capability rawListMimeCapability4 {MEDIA_MIME_AUDIO_RAW}; 159 rawListMimeCapability4.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 4100}); 160 ASSERT_FALSE(Pipeline::MergeCapabilityKeys(rawListMimeCapability4, rawListMimeCapability, out)); 161 ASSERT_TRUE(out.mime.empty()); 162 ASSERT_TRUE(out.keys.empty()); 163 Capability rawIntervalMimeCapability {MEDIA_MIME_AUDIO_RAW}; 164 rawIntervalMimeCapability.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000, 48000); 165 ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability, wildMimeCapability, out)); 166 ASSERT_TRUE(out.mime.empty()); 167 auto intCaps = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 168 ASSERT_TRUE(intCaps.first == 8000); 169 ASSERT_TRUE(intCaps.second == 48000); 170 // inter apply with fix 171 ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawFixedMimeCapability, rawIntervalMimeCapability, out)); 172 ASSERT_TRUE(out.mime.empty()); 173 ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000); 174 ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability, rawFixedMimeCapability, out)); 175 ASSERT_TRUE(out.mime.empty()); 176 ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000); 177 Capability rawFixedMimeCapability5 (MEDIA_MIME_AUDIO_RAW); 178 rawFixedMimeCapability5.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 4000); 179 ASSERT_FALSE(Pipeline::MergeCapabilityKeys(rawFixedMimeCapability5, rawIntervalMimeCapability, out)); 180 ASSERT_TRUE(out.mime.empty()); 181 ASSERT_TRUE(out.keys.empty()); 182 } 183 184 HWTEST(TestMergeCapabilityKeys, SingleType3_Test, TestSize.Level1) 185 { 186 Capability wildMimeCapability("*"); 187 Capability out; 188 Capability rawIntervalMimeCapability {MEDIA_MIME_AUDIO_RAW}; 189 rawIntervalMimeCapability.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000, 48000); 190 // inter apply with inter 191 Capability rawIntervalMimeCapability2 {MEDIA_MIME_AUDIO_RAW}; 192 rawIntervalMimeCapability2.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 3000, 9000); 193 ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability2, rawIntervalMimeCapability, out)); 194 ASSERT_TRUE(out.mime.empty()); 195 auto intCaps2 = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 196 ASSERT_TRUE(intCaps2.first == 8000); 197 ASSERT_TRUE(intCaps2.second == 9000); 198 199 ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability, rawIntervalMimeCapability2, out)); 200 ASSERT_TRUE(out.mime.empty()); 201 auto intCaps3 = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 202 ASSERT_TRUE(intCaps3.first == 8000); 203 ASSERT_TRUE(intCaps3.second == 9000); 204 205 Capability rawIntervalMimeCapability3 {MEDIA_MIME_AUDIO_RAW}; 206 rawIntervalMimeCapability3.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 3000, 4000); 207 ASSERT_FALSE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability3, rawIntervalMimeCapability, out)); 208 ASSERT_TRUE(out.mime.empty()); 209 ASSERT_TRUE(out.keys.empty()); 210 211 // inter apply with discrete 212 Capability rawListMimeCapability5 {MEDIA_MIME_AUDIO_RAW}; 213 rawListMimeCapability5.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 4100}); 214 ASSERT_FALSE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability, rawListMimeCapability5, out)); 215 ASSERT_TRUE(out.mime.empty()); 216 ASSERT_TRUE(out.keys.empty()); 217 218 Capability rawListMimeCapability6 {MEDIA_MIME_AUDIO_RAW}; 219 rawListMimeCapability6.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 44100}); 220 ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability, rawListMimeCapability6, out)); 221 ASSERT_TRUE(out.mime.empty()); 222 auto intCaps4 = Plugin::AnyCast<Plugin::FixedCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 223 ASSERT_TRUE(intCaps4 == 44100); 224 225 Capability rawListMimeCapability7 {MEDIA_MIME_AUDIO_RAW}; 226 rawListMimeCapability7.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 40000, 44100}); 227 ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability, rawListMimeCapability7, out)); 228 ASSERT_TRUE(out.mime.empty()); 229 auto intCaps5 = Plugin::AnyCast<Plugin::DiscreteCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 230 ASSERT_TRUE(intCaps5.size() == 2); 231 ASSERT_TRUE(intCaps5[0] == 40000); 232 ASSERT_TRUE(intCaps5[1] == 44100); 233 } 234 235 HWTEST(TestMergeCapability, SingleType1_Test, TestSize.Level1) 236 { 237 Capability wildMimeCapability("*"); 238 Capability out; 239 240 Capability rawFixedMimeCapability (MEDIA_MIME_AUDIO_RAW); 241 rawFixedMimeCapability.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000); 242 243 ASSERT_TRUE(Pipeline::MergeCapability(rawFixedMimeCapability, wildMimeCapability, out)); 244 ASSERT_TRUE(out.mime == rawFixedMimeCapability.mime); 245 ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000); 246 247 Capability rawFixedMimeCapability2 (MEDIA_MIME_AUDIO_RAW); 248 rawFixedMimeCapability2.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000); 249 250 // fix apply with fix 251 ASSERT_TRUE(Pipeline::MergeCapability(rawFixedMimeCapability, rawFixedMimeCapability2, out)); 252 ASSERT_TRUE(out.mime == rawFixedMimeCapability.mime); 253 ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000); 254 255 // apply failed 256 Capability rawFixedMimeCapability3 (MEDIA_MIME_AUDIO_RAW); 257 rawFixedMimeCapability3.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 4000); 258 ASSERT_FALSE(Pipeline::MergeCapability(rawFixedMimeCapability, rawFixedMimeCapability3, out)); 259 ASSERT_TRUE(out.mime.empty()); 260 ASSERT_TRUE(out.keys.empty()); 261 262 Capability rawListMimeCapability {MEDIA_MIME_AUDIO_RAW}; 263 rawListMimeCapability.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {8000, 32000, 48000, 44100}); 264 265 ASSERT_TRUE(Pipeline::MergeCapability(rawListMimeCapability, wildMimeCapability, out)); 266 ASSERT_TRUE(out.mime == rawListMimeCapability.mime); 267 auto disCaps = Plugin::AnyCast<Plugin::DiscreteCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 268 ASSERT_TRUE(disCaps[0] == 8000); 269 ASSERT_TRUE(disCaps[1] == 32000); 270 ASSERT_TRUE(disCaps[2] == 48000); 271 ASSERT_TRUE(disCaps[3] == 44100); 272 273 // fix apply with discrete 274 ASSERT_TRUE(Pipeline::MergeCapability(rawFixedMimeCapability, rawListMimeCapability, out)); 275 ASSERT_TRUE(out.mime == rawFixedMimeCapability.mime); 276 ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000); 277 278 // apply failed 279 Capability rawFixedMimeCapability4 (MEDIA_MIME_AUDIO_RAW); 280 rawFixedMimeCapability4.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 4000); 281 ASSERT_FALSE(Pipeline::MergeCapability(rawFixedMimeCapability4, rawListMimeCapability, out)); 282 ASSERT_TRUE(out.mime.empty()); 283 ASSERT_TRUE(out.keys.empty()); 284 } 285 286 HWTEST(TestMergeCapability, SingleType2_Test, TestSize.Level1) 287 { 288 Capability wildMimeCapability("*"); 289 Capability out; 290 Capability rawFixedMimeCapability (MEDIA_MIME_AUDIO_RAW); 291 rawFixedMimeCapability.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000); 292 Capability rawListMimeCapability {MEDIA_MIME_AUDIO_RAW}; 293 rawListMimeCapability.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {8000, 32000, 48000, 44100}); 294 // discrete apply with discrete 295 Capability rawListMimeCapability2 {MEDIA_MIME_AUDIO_RAW}; 296 rawListMimeCapability2.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 48000, 44100}); 297 ASSERT_TRUE(Pipeline::MergeCapability(rawListMimeCapability2, rawListMimeCapability, out)); 298 ASSERT_TRUE(out.mime == rawListMimeCapability2.mime); 299 auto tmp1 = Plugin::AnyCast<Plugin::DiscreteCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 300 ASSERT_TRUE(tmp1.size() == 2); 301 ASSERT_TRUE(tmp1[0] == 48000); 302 ASSERT_TRUE(tmp1[1] == 44100); 303 // discrete apply with discrete 304 Capability rawListMimeCapability3 {MEDIA_MIME_AUDIO_RAW}; 305 rawListMimeCapability3.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 44100}); 306 ASSERT_TRUE(Pipeline::MergeCapability(rawListMimeCapability3, rawListMimeCapability, out)); 307 ASSERT_TRUE(out.mime == rawListMimeCapability3.mime); 308 auto tmp2 = Plugin::AnyCast<Plugin::FixedCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 309 ASSERT_TRUE(tmp2 == 44100); 310 // discrete apply with discrete failed 311 Capability rawListMimeCapability4 {MEDIA_MIME_AUDIO_RAW}; 312 rawListMimeCapability4.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 4100}); 313 ASSERT_FALSE(Pipeline::MergeCapability(rawListMimeCapability4, rawListMimeCapability, out)); 314 ASSERT_TRUE(out.mime.empty()); 315 ASSERT_TRUE(out.keys.empty()); 316 Capability rawIntervalMimeCapability {MEDIA_MIME_AUDIO_RAW}; 317 rawIntervalMimeCapability.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000, 48000); 318 ASSERT_TRUE(Pipeline::MergeCapability(rawIntervalMimeCapability, wildMimeCapability, out)); 319 ASSERT_TRUE(out.mime == rawIntervalMimeCapability.mime); 320 auto intCaps = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 321 ASSERT_TRUE(intCaps.first == 8000); 322 ASSERT_TRUE(intCaps.second == 48000); 323 // inter apply with fix 324 ASSERT_TRUE(Pipeline::MergeCapability(rawFixedMimeCapability, rawIntervalMimeCapability, out)); 325 ASSERT_TRUE(out.mime == rawFixedMimeCapability.mime); 326 ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000); 327 ASSERT_TRUE(Pipeline::MergeCapability(rawIntervalMimeCapability, rawFixedMimeCapability, out)); 328 ASSERT_TRUE(out.mime == rawIntervalMimeCapability.mime); 329 ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000); 330 Capability rawFixedMimeCapability5 (MEDIA_MIME_AUDIO_RAW); 331 rawFixedMimeCapability5.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 4000); 332 ASSERT_FALSE(Pipeline::MergeCapability(rawFixedMimeCapability5, rawIntervalMimeCapability, out)); 333 ASSERT_TRUE(out.mime.empty()); 334 ASSERT_TRUE(out.keys.empty()); 335 } 336 337 HWTEST(TestMergeCapability, SingleType3_Test, TestSize.Level1) 338 { 339 Capability wildMimeCapability("*"); 340 Capability out; 341 Capability rawIntervalMimeCapability {MEDIA_MIME_AUDIO_RAW}; 342 rawIntervalMimeCapability.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000, 48000); 343 // inter apply with inter 344 Capability rawIntervalMimeCapability2 {MEDIA_MIME_AUDIO_RAW}; 345 rawIntervalMimeCapability2.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 3000, 9000); 346 ASSERT_TRUE(Pipeline::MergeCapability(rawIntervalMimeCapability2, rawIntervalMimeCapability, out)); 347 ASSERT_TRUE(out.mime == rawIntervalMimeCapability2.mime); 348 auto intCaps2 = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 349 ASSERT_TRUE(intCaps2.first == 8000); 350 ASSERT_TRUE(intCaps2.second == 9000); 351 352 ASSERT_TRUE(Pipeline::MergeCapability(rawIntervalMimeCapability, rawIntervalMimeCapability2, out)); 353 ASSERT_TRUE(out.mime == rawIntervalMimeCapability.mime); 354 auto intCaps3 = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 355 ASSERT_TRUE(intCaps3.first == 8000); 356 ASSERT_TRUE(intCaps3.second == 9000); 357 358 Capability rawIntervalMimeCapability3 {MEDIA_MIME_AUDIO_RAW}; 359 rawIntervalMimeCapability3.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 3000, 4000); 360 ASSERT_FALSE(Pipeline::MergeCapability(rawIntervalMimeCapability3, rawIntervalMimeCapability, out)); 361 ASSERT_TRUE(out.mime.empty()); 362 ASSERT_TRUE(out.keys.empty()); 363 364 // inter apply with discrete 365 Capability rawListMimeCapability5 {MEDIA_MIME_AUDIO_RAW}; 366 rawListMimeCapability5.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 4100}); 367 ASSERT_FALSE(Pipeline::MergeCapability(rawIntervalMimeCapability, rawListMimeCapability5, out)); 368 ASSERT_TRUE(out.mime.empty()); 369 ASSERT_TRUE(out.keys.empty()); 370 371 Capability rawListMimeCapability6 {MEDIA_MIME_AUDIO_RAW}; 372 rawListMimeCapability6.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 44100}); 373 ASSERT_TRUE(Pipeline::MergeCapability(rawIntervalMimeCapability, rawListMimeCapability6, out)); 374 ASSERT_TRUE(out.mime == rawIntervalMimeCapability.mime); 375 auto intCaps4 = Plugin::AnyCast<Plugin::FixedCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 376 ASSERT_TRUE(intCaps4 == 44100); 377 378 Capability rawListMimeCapability7 {MEDIA_MIME_AUDIO_RAW}; 379 rawListMimeCapability7.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 40000, 44100}); 380 ASSERT_TRUE(Pipeline::MergeCapability(rawIntervalMimeCapability, rawListMimeCapability7, out)); 381 ASSERT_TRUE(out.mime == rawIntervalMimeCapability.mime); 382 auto intCaps5 = Plugin::AnyCast<Plugin::DiscreteCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]); 383 ASSERT_TRUE(intCaps5.size() == 2); 384 ASSERT_TRUE(intCaps5[0] == 40000); 385 ASSERT_TRUE(intCaps5[1] == 44100); 386 } 387 388 HWTEST(TestMergeCapability, ComplexType_Test1, TestSize.Level1) 389 { 390 Capability wildMimeCapability("*"); 391 Capability out; 392 393 Capability cap1 (MEDIA_MIME_AUDIO_RAW); 394 cap1.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000); 395 cap1.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_CHANNELS, 2, 8); 396 cap1.AppendDiscreteKeys<Plugin::AudioSampleFormat>(CapabilityID::AUDIO_SAMPLE_FORMAT, { 397 Plugin::AudioSampleFormat::S64, Plugin::AudioSampleFormat::S64P, Plugin::AudioSampleFormat::U64, 398 Plugin::AudioSampleFormat::U64P, Plugin::AudioSampleFormat::F64, 399 }); 400 401 Capability cap2(MEDIA_MIME_AUDIO_APE); 402 403 ASSERT_FALSE(Pipeline::MergeCapability(cap1, cap2, out)); 404 ASSERT_TRUE(out.mime.empty()); 405 ASSERT_TRUE(out.keys.empty()); 406 407 Capability cap3(MEDIA_MIME_AUDIO_RAW); 408 ASSERT_TRUE(Pipeline::MergeCapability(cap1, cap3, out)); 409 ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000); 410 auto intCaps = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_CHANNELS]); 411 ASSERT_TRUE(intCaps.first == 2); 412 ASSERT_TRUE(intCaps.second == 8); 413 auto disCaps = Plugin::AnyCast<Plugin::DiscreteCapability<Plugin::AudioSampleFormat>>( 414 out.keys[CapabilityID::AUDIO_SAMPLE_FORMAT]); 415 ASSERT_TRUE(disCaps.size() == 5); 416 ASSERT_TRUE(disCaps[0] == Plugin::AudioSampleFormat::S64); 417 ASSERT_TRUE(disCaps[1] == Plugin::AudioSampleFormat::S64P); 418 ASSERT_TRUE(disCaps[2] == Plugin::AudioSampleFormat::U64); 419 ASSERT_TRUE(disCaps[3] == Plugin::AudioSampleFormat::U64P); 420 ASSERT_TRUE(disCaps[4] == Plugin::AudioSampleFormat::F64); 421 } 422 423 HWTEST(TestApplyCapabilitySet, ComplexType_Test3, TestSize.Level1) 424 { 425 Capability out; 426 427 Capability cap1 (MEDIA_MIME_AUDIO_RAW); 428 cap1.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000); 429 cap1.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_CHANNELS, 2, 8); 430 cap1.AppendDiscreteKeys<Plugin::AudioSampleFormat>(CapabilityID::AUDIO_SAMPLE_FORMAT, { 431 Plugin::AudioSampleFormat::S64, Plugin::AudioSampleFormat::S64P, Plugin::AudioSampleFormat::U64, 432 Plugin::AudioSampleFormat::U64P, Plugin::AudioSampleFormat::F64, 433 }); 434 435 Capability cap2(MEDIA_MIME_AUDIO_APE); 436 Capability cap3(MEDIA_MIME_AUDIO_RAW); 437 438 Capability cap4(MEDIA_MIME_AUDIO_RAW); 439 cap4.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000, 96000); 440 cap4.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_CHANNELS, 4); 441 cap4.AppendDiscreteKeys<Plugin::AudioChannelLayout>(CapabilityID::AUDIO_CHANNEL_LAYOUT, { 442 Plugin::AudioChannelLayout::STEREO, Plugin::AudioChannelLayout::SURROUND, 443 Plugin::AudioChannelLayout::CH_5POINT1, Plugin::AudioChannelLayout::CH_7POINT1, 444 }); 445 446 Capability cap5(MEDIA_MIME_AUDIO_RAW); 447 cap5.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000, 96000); 448 cap5.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_CHANNELS, 10); 449 cap5.AppendDiscreteKeys<Plugin::AudioChannelLayout>(CapabilityID::AUDIO_CHANNEL_LAYOUT, { 450 Plugin::AudioChannelLayout::STEREO, Plugin::AudioChannelLayout::SURROUND, 451 Plugin::AudioChannelLayout::CH_5POINT1, Plugin::AudioChannelLayout::CH_7POINT1, 452 }); 453 454 CapabilitySet capSet1 = {cap2, cap3}; 455 ASSERT_TRUE(Pipeline::ApplyCapabilitySet(cap1, capSet1, out)); 456 ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000); 457 auto intCaps = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_CHANNELS]); 458 ASSERT_TRUE(intCaps.first == 2); 459 ASSERT_TRUE(intCaps.second == 8); 460 auto disCaps = Plugin::AnyCast<Plugin::DiscreteCapability<Plugin::AudioSampleFormat>>( 461 out.keys[CapabilityID::AUDIO_SAMPLE_FORMAT]); 462 ASSERT_TRUE(disCaps.size() == 5); 463 ASSERT_TRUE(disCaps[0] == Plugin::AudioSampleFormat::S64); 464 ASSERT_TRUE(disCaps[1] == Plugin::AudioSampleFormat::S64P); 465 ASSERT_TRUE(disCaps[2] == Plugin::AudioSampleFormat::U64); 466 ASSERT_TRUE(disCaps[3] == Plugin::AudioSampleFormat::U64P); 467 ASSERT_TRUE(disCaps[4] == Plugin::AudioSampleFormat::F64); 468 469 CapabilitySet capSet2 = {cap2, cap5}; 470 ASSERT_FALSE(Pipeline::ApplyCapabilitySet(cap1, capSet2, out)); 471 ASSERT_TRUE(out.mime.empty()); 472 ASSERT_TRUE(out.keys.empty()); 473 } 474 475 HWTEST(TestMetaToCap, MetaToCap_Test, TestSize.Level1) 476 { 477 Meta meta; 478 meta.Set<Plugin::Tag::MIME>(MEDIA_MIME_AUDIO_RAW); 479 meta.Set<Plugin::Tag::AUDIO_MPEG_VERSION>(1); 480 meta.Set<Tag::AUDIO_CHANNEL_LAYOUT>(AudioChannelLayout::STEREO); 481 meta.Set<Plugin::Tag::AUDIO_CHANNELS>(2); 482 meta.Set<Plugin::Tag::AUDIO_SAMPLE_RATE>(48000); 483 auto cap = Pipeline::MetaToCapability(meta); 484 ASSERT_STREQ(MEDIA_MIME_AUDIO_RAW, cap->mime.c_str()); 485 auto mpegVersion = Plugin::AnyCast<uint32_t>(cap->keys[CapabilityID::AUDIO_MPEG_VERSION]); 486 ASSERT_TRUE(mpegVersion == 1); 487 488 auto channelLayout = Plugin::AnyCast<AudioChannelLayout>(cap->keys[CapabilityID::AUDIO_CHANNEL_LAYOUT]); 489 ASSERT_TRUE(channelLayout == AudioChannelLayout::STEREO); 490 491 auto channels = Plugin::AnyCast<uint32_t>(cap->keys[CapabilityID::AUDIO_CHANNELS]); 492 ASSERT_TRUE(channels == 2); 493 494 auto sampleRate = Plugin::AnyCast<uint32_t>(cap->keys[CapabilityID::AUDIO_SAMPLE_RATE]); 495 ASSERT_TRUE(sampleRate == 48000); 496 } 497 498 HWTEST(TestMergeMetaWithCapability, MergeMetaWithEmptyKeyCapability_Test, TestSize.Level1) 499 { 500 Meta meta; 501 meta.Set<Plugin::Tag::MIME>(MEDIA_MIME_AUDIO_MPEG); 502 meta.Set<Plugin::Tag::AUDIO_MPEG_VERSION>(1); 503 meta.Set<Plugin::Tag::AUDIO_CHANNEL_LAYOUT>(AudioChannelLayout::STEREO); 504 meta.Set<Plugin::Tag::AUDIO_CHANNELS>(2); 505 meta.Set<Plugin::Tag::AUDIO_SAMPLE_RATE>(48000); 506 meta.Set<Plugin::Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::U16P); 507 508 Capability cap0(MEDIA_MIME_AUDIO_RAW); 509 Meta out1; 510 std::string outMime1; 511 uint32_t outMpegVersion1 = 0; 512 AudioChannelLayout outAudioChannelLayout1; 513 uint32_t outChannels1 = 0; 514 uint32_t outSampleRate1 = 0; 515 AudioSampleFormat outSampleFormat1 = AudioSampleFormat::U8; 516 ASSERT_TRUE(Pipeline::MergeMetaWithCapability(meta, cap0, out1)); 517 ASSERT_TRUE(out1.Get<Tag::MIME>(outMime1)); 518 ASSERT_STREQ(outMime1.c_str(), MEDIA_MIME_AUDIO_RAW); 519 ASSERT_TRUE(out1.Get<Tag::AUDIO_MPEG_VERSION>(outMpegVersion1)); 520 ASSERT_TRUE(outMpegVersion1 == 1); 521 ASSERT_TRUE(out1.Get<Tag::AUDIO_CHANNEL_LAYOUT>(outAudioChannelLayout1)); 522 ASSERT_TRUE(outAudioChannelLayout1 == AudioChannelLayout::STEREO); 523 ASSERT_TRUE(out1.Get<Tag::AUDIO_CHANNELS>(outChannels1)); 524 ASSERT_TRUE(outChannels1 == 2); 525 ASSERT_TRUE(out1.Get<Tag::AUDIO_SAMPLE_RATE>(outSampleRate1)); 526 ASSERT_TRUE(outSampleRate1 == 48000); 527 ASSERT_TRUE(out1.Get<Tag::AUDIO_SAMPLE_FORMAT>(outSampleFormat1)); 528 ASSERT_TRUE(outSampleFormat1 == AudioSampleFormat::U16P); 529 } 530 531 HWTEST(TestMergeMetaWithCapability, Merge_meta_contains_meta_ony_key_capability_Test, TestSize.Level1) 532 { 533 Meta meta; 534 meta.Set<Plugin::Tag::MIME>(MEDIA_MIME_AUDIO_MPEG); 535 meta.Set<Plugin::Tag::AUDIO_MPEG_VERSION>(1); 536 meta.Set<Tag::AUDIO_CHANNEL_LAYOUT>(AudioChannelLayout::STEREO); 537 meta.Set<Plugin::Tag::AUDIO_CHANNELS>(2); 538 meta.Set<Plugin::Tag::AUDIO_SAMPLE_RATE>(48000); 539 meta.Set<Plugin::Tag::MEDIA_BITRATE>(128000); 540 541 Capability cap0(MEDIA_MIME_AUDIO_RAW); 542 cap0.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_MPEG_VERSION, 1); 543 cap0.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 48000); 544 cap0.AppendDiscreteKeys<AudioChannelLayout>(CapabilityID::AUDIO_CHANNEL_LAYOUT, 545 {AudioChannelLayout::STEREO, AudioChannelLayout::SURROUND}); 546 cap0.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_CHANNELS, 1, 8); 547 cap0.AppendDiscreteKeys<AudioSampleFormat>(CapabilityID::AUDIO_SAMPLE_FORMAT, 548 {AudioSampleFormat::U16P, AudioSampleFormat::U8}); 549 cap0.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_MPEG_LAYER, 3, 7); 550 551 Meta out1; 552 std::string outMime1; 553 uint32_t outMpegVersion1 = 0; 554 AudioChannelLayout outAudioChannelLayout1; 555 uint32_t outChannels1 = 0; 556 uint32_t outSampleRate1 = 0; 557 AudioSampleFormat outSampleFormat1 = AudioSampleFormat::U8; 558 uint32_t outMpegLayer = 0; 559 int64_t outBitRate = 0; 560 561 ASSERT_TRUE(Pipeline::MergeMetaWithCapability(meta, cap0, out1)); 562 ASSERT_TRUE(out1.Get<Tag::MIME>(outMime1)); 563 ASSERT_STREQ(outMime1.c_str(), MEDIA_MIME_AUDIO_RAW); 564 ASSERT_TRUE(out1.Get<Tag::AUDIO_MPEG_VERSION>(outMpegVersion1)); 565 ASSERT_TRUE(outMpegVersion1 == 1); 566 ASSERT_TRUE(out1.Get<Tag::AUDIO_CHANNEL_LAYOUT>(outAudioChannelLayout1)); 567 ASSERT_TRUE(outAudioChannelLayout1 == AudioChannelLayout::STEREO); 568 ASSERT_TRUE(out1.Get<Tag::AUDIO_CHANNELS>(outChannels1)); 569 ASSERT_TRUE(outChannels1 == 2); 570 ASSERT_TRUE(out1.Get<Tag::AUDIO_SAMPLE_RATE>(outSampleRate1)); 571 ASSERT_TRUE(outSampleRate1 == 48000); 572 ASSERT_TRUE(out1.Get<Tag::AUDIO_SAMPLE_FORMAT>(outSampleFormat1)); 573 ASSERT_TRUE(outSampleFormat1 == AudioSampleFormat::U16P); 574 ASSERT_TRUE(out1.Get<Tag::AUDIO_MPEG_LAYER>(outMpegLayer)); 575 ASSERT_TRUE(outMpegLayer == 3); 576 ASSERT_TRUE(out1.Get<Tag::MEDIA_BITRATE>(outBitRate)); 577 ASSERT_TRUE(outBitRate == 128000); 578 } 579 580 HWTEST(TestMergeMetaWithCapability, Merge_meta_with_capability_failed_Test, TestSize.Level1) 581 { 582 Meta meta; 583 meta.Set<Plugin::Tag::MIME>(MEDIA_MIME_AUDIO_MPEG); 584 meta.Set<Plugin::Tag::AUDIO_MPEG_VERSION>(1); 585 meta.Set<Tag::AUDIO_CHANNEL_LAYOUT>(AudioChannelLayout::STEREO); 586 meta.Set<Plugin::Tag::AUDIO_CHANNELS>(2); 587 meta.Set<Plugin::Tag::AUDIO_SAMPLE_RATE>(48000); 588 meta.Set<Plugin::Tag::MEDIA_BITRATE>(128000); 589 590 Capability cap0(MEDIA_MIME_AUDIO_RAW); 591 cap0.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_MPEG_VERSION, 2); 592 Meta out1; 593 ASSERT_FALSE(Pipeline::MergeMetaWithCapability(meta, cap0, out1)); 594 595 Capability cap1(MEDIA_MIME_AUDIO_RAW); 596 cap1.AppendDiscreteKeys<AudioChannelLayout>(CapabilityID::AUDIO_CHANNEL_LAYOUT, 597 {AudioChannelLayout::CH_5POINT1, AudioChannelLayout::SURROUND}); 598 Meta out2; 599 ASSERT_FALSE(Pipeline::MergeMetaWithCapability(meta, cap1, out2)); 600 601 602 Capability cap2(MEDIA_MIME_AUDIO_RAW); 603 cap2.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_CHANNELS, 3, 8); 604 Meta out3; 605 ASSERT_FALSE(Pipeline::MergeMetaWithCapability(meta, cap2, out3)); 606 } 607 }