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 {
HWTEST(TestApplyCapability, mime_Test, TestSize.Level1)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
HWTEST(TestMergeCapabilityKeys, SingleType1_Test, TestSize.Level1)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
HWTEST(TestMergeCapabilityKeys, SingleType2_Test, TestSize.Level1)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
HWTEST(TestMergeCapabilityKeys, SingleType3_Test, TestSize.Level1)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
HWTEST(TestMergeCapability, SingleType1_Test, TestSize.Level1)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
HWTEST(TestMergeCapability, SingleType2_Test, TestSize.Level1)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
HWTEST(TestMergeCapability, SingleType3_Test, TestSize.Level1)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
HWTEST(TestMergeCapability, ComplexType_Test1, TestSize.Level1)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
HWTEST(TestApplyCapabilitySet, ComplexType_Test3, TestSize.Level1)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
HWTEST(TestMetaToCap, MetaToCap_Test, TestSize.Level1)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
HWTEST(TestMergeMetaWithCapability, MergeMetaWithEmptyKeyCapability_Test, TestSize.Level1)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
HWTEST(TestMergeMetaWithCapability, Merge_meta_contains_meta_ony_key_capability_Test, TestSize.Level1)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
HWTEST(TestMergeMetaWithCapability, Merge_meta_with_capability_failed_Test, TestSize.Level1)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 }