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