1use glib::{
4 prelude::*,
5 translate::{from_glib, ToGlibPtr},
6 FlagsClass,
7};
8
9bitflags_serde_impl!(crate::BinFlags);
10bitflags_serde_impl!(crate::BufferCopyFlags);
11bitflags_serde_impl!(crate::BufferFlags);
12bitflags_serde_impl!(crate::BufferPoolAcquireFlags);
13bitflags_serde_impl!(crate::ClockFlags);
14
15impl serde::Serialize for crate::DebugColorFlags {
16 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
17 where
18 S: serde::Serializer,
19 {
20 serializer.serialize_str(&format!(
21 "{}+{}{}{}",
22 match *self & Self::from_bits(0b111).expect("Failed to create value from fg-color mask")
23 {
24 Self::FG_BLACK => "fg-black",
25 Self::FG_RED => "fg-red",
26 Self::FG_GREEN => "fg-green",
27 Self::FG_YELLOW => "fg-yellow",
28 Self::FG_BLUE => "fg-blue",
29 Self::FG_MAGENTA => "fg-magenta",
30 Self::FG_CYAN => "fg-cyan",
31 Self::FG_WHITE => "fg-white",
32 _ => unreachable!(),
33 },
34 match *self
35 & Self::from_bits(0b111_0000).expect("Failed to create value from bg-color mask")
36 {
37 Self::BG_BLACK => "bg-black",
38 Self::BG_RED => "bg-red",
39 Self::BG_GREEN => "bg-green",
40 Self::BG_YELLOW => "bg-yellow",
41 Self::BG_BLUE => "bg-blue",
42 Self::BG_MAGENTA => "bg-magenta",
43 Self::BG_CYAN => "bg-cyan",
44 Self::BG_WHITE => "bg-white",
45 _ => unreachable!(),
46 },
47 if self.contains(Self::BOLD) {
48 "+bold"
49 } else {
50 ""
51 },
52 if self.contains(Self::UNDERLINE) {
53 "+underline"
54 } else {
55 ""
56 }
57 ))
58 }
59}
60
61bitflags_deserialize_impl!(crate::DebugColorFlags);
62bitflags_serialize_impl!(crate::DebugGraphDetails, by_ones_decreasing);
63bitflags_deserialize_impl!(crate::DebugGraphDetails);
64bitflags_serde_impl!(crate::ElementFlags);
65bitflags_serde_impl!(crate::EventTypeFlags);
66bitflags_serde_impl!(crate::GapFlags, "v1_20");
67bitflags_serde_impl!(crate::MemoryFlags);
68bitflags_serde_impl!(crate::MetaFlags);
69bitflags_serde_impl!(crate::ObjectFlags);
70bitflags_serde_impl!(crate::PadFlags);
71bitflags_serde_impl!(crate::PadLinkCheck);
72bitflags_serde_impl!(crate::PadProbeType);
73bitflags_serde_impl!(crate::ParseFlags);
74bitflags_serde_impl!(crate::PluginAPIFlags, "v1_18");
75bitflags_serde_impl!(crate::PluginDependencyFlags);
76bitflags_serde_impl!(crate::PluginFlags);
77bitflags_serde_impl!(crate::SchedulingFlags);
78bitflags_serde_impl!(crate::SeekFlags);
79bitflags_serde_impl!(crate::SegmentFlags);
80bitflags_serde_impl!(crate::SerializeFlags, "v1_20");
81bitflags_serde_impl!(crate::StackTraceFlags);
82bitflags_serde_impl!(crate::StreamFlags);
83bitflags_serde_impl!(crate::StreamType);
84
85#[cfg(test)]
86mod tests {
87 macro_rules! check_serialize {
88 ($flags:expr, $expected:expr) => {
89 let actual = serde_json::to_string(&$flags).unwrap();
90 assert_eq!(actual, $expected);
91 };
92 }
93
94 macro_rules! check_deserialize {
95 ($ty:ty, $expected:expr, $json:expr) => {
96 let actual: $ty = serde_json::from_str(&$json).unwrap();
97 assert_eq!(actual, $expected);
98 };
99 }
100
101 macro_rules! check_roundtrip {
102 ($ty:ty, $flags:expr) => {
103 let json = serde_json::to_string(&$flags).unwrap();
104 let deserialized: $ty = serde_json::from_str(&json).unwrap();
105 assert_eq!(deserialized, $flags);
106 };
107 }
108
109 #[test]
110 fn test_serialize() {
111 crate::init().unwrap();
112
113 check_serialize!(crate::BinFlags::empty(), "\"\"");
114 check_serialize!(crate::BinFlags::all(), "\"no-resync+streams-aware\"");
115 check_serialize!(
116 crate::BufferCopyFlags::all(),
117 "\"flags+timestamps+meta+memory+merge+deep\""
118 );
119 check_serialize!(
120 crate::BufferFlags::all(),
121 concat!(
122 "\"live+decode-only+discont+resync+corrupted+marker+header+gap",
123 "+droppable+delta-unit+tag-memory+sync-after+non-droppable\""
124 )
125 );
126 check_serialize!(
127 crate::BufferPoolAcquireFlags::all(),
128 "\"key-unit+dontwait+discont\""
129 );
130 check_serialize!(
131 crate::ClockFlags::all(),
132 concat!(
133 "\"can-do-single-sync+can-do-single-async",
134 "+can-do-periodic-sync+can-do-periodic-async",
135 "+can-set-resolution+can-set-master+needs-startup-sync\""
136 )
137 );
138
139 check_serialize!(
140 crate::DebugColorFlags::all(),
141 "\"fg-white+bg-white+bold+underline\""
142 );
143 check_serialize!(
144 crate::DebugColorFlags::FG_MAGENTA | crate::DebugColorFlags::BOLD,
145 "\"fg-magenta+bg-black+bold\""
146 );
147 check_serialize!(
148 crate::DebugColorFlags::FG_RED
149 | crate::DebugColorFlags::FG_BLUE
150 | crate::DebugColorFlags::BG_BLACK,
151 "\"fg-magenta+bg-black\""
152 );
153
154 check_serialize!(crate::DebugGraphDetails::all(), "\"verbose\"");
155 check_serialize!(
156 crate::DebugGraphDetails::MEDIA_TYPE
157 | crate::DebugGraphDetails::CAPS_DETAILS
158 | crate::DebugGraphDetails::NON_DEFAULT_PARAMS
159 | crate::DebugGraphDetails::STATES
160 | crate::DebugGraphDetails::FULL_PARAMS
161 | crate::DebugGraphDetails::ALL,
162 "\"all+full-params\""
163 );
164 check_serialize!(
165 crate::DebugGraphDetails::MEDIA_TYPE
166 | crate::DebugGraphDetails::CAPS_DETAILS
167 | crate::DebugGraphDetails::NON_DEFAULT_PARAMS
168 | crate::DebugGraphDetails::STATES
169 | crate::DebugGraphDetails::FULL_PARAMS,
170 "\"all+full-params\""
171 );
172
173 check_serialize!(
174 crate::ElementFlags::all(),
175 "\"locked-state+sink+source+provide-clock+require-clock+indexable\""
176 );
177 check_serialize!(
178 crate::EventTypeFlags::all(),
179 "\"upstream+downstream+serialized+sticky+sticky-multi\""
180 );
181 #[cfg(feature = "v1_20")]
182 check_serialize!(crate::GapFlags::all(), "\"data\"");
183 check_serialize!(
184 crate::MemoryFlags::all(),
185 concat!(
186 "\"readonly+no-share+zero-prefixed+zero-padded",
187 "+physically-contiguous+not-mappable\""
188 )
189 );
190 check_serialize!(crate::MetaFlags::all(), "\"readonly+pooled+locked\"");
191 cfg_if::cfg_if! {
192 if #[cfg(feature = "v1_24")] {
193 check_serialize!(crate::ObjectFlags::all(), "\"may-be-leaked+constructed\"");
194 } else {
195 check_serialize!(crate::ObjectFlags::all(), "\"may-be-leaked\"");
196 }
197 }
198 check_serialize!(
199 crate::PadFlags::all(),
200 concat!(
201 "\"blocked+flushing+eos+blocking+need-parent+need-reconfigure",
202 "+pending-events+fixed-caps+proxy-caps+proxy-allocation",
203 "+proxy-scheduling+accept-intersect+accept-template\""
204 )
205 );
206 check_serialize!(
207 crate::PadLinkCheck::all(),
208 "\"hierarchy+template-caps+caps+no-reconfigure\""
209 );
210 check_serialize!(
211 crate::PadProbeType::all(),
212 concat!(
213 "\"idle+block+buffer+buffer-list+event-downstream",
214 "+event-upstream+event-flush+query-downstream+query-upstream",
215 "+push+pull\""
216 )
217 );
218 check_serialize!(
219 crate::ParseFlags::all(),
220 "\"fatal-errors+no-single-element-bins+place-in-bin\""
221 );
222 #[cfg(feature = "v1_18")]
223 check_serialize!(crate::PluginAPIFlags::all(), "\"members\"");
224 check_serialize!(
225 crate::PluginDependencyFlags::all(),
226 concat!(
227 "\"recurse+paths-are-default-only+file-name-is-suffix",
228 "+file-name-is-prefix+paths-are-relative-to-exe\""
229 )
230 );
231 check_serialize!(crate::PluginFlags::all(), "\"cached+blacklisted\"");
232 check_serialize!(
233 crate::SchedulingFlags::all(),
234 "\"seekable+sequential+bandwidth-limited\""
235 );
236 #[cfg(feature = "v1_18")]
237 check_serialize!(
238 crate::SeekFlags::all(),
239 concat!(
240 "\"flush+accurate+key-unit+segment+trickmode+snap-before",
241 "+snap-after+trickmode-key-units+trickmode-no-audio",
242 "+trickmode-forward-predicted+instant-rate-change\""
243 )
244 );
245 #[cfg(feature = "v1_18")]
246 check_serialize!(
247 crate::SegmentFlags::all(),
248 concat!(
249 "\"reset+trickmode+segment+trickmode-key-units",
250 "+trickmode-forward-predicted+trickmode-no-audio\""
251 )
252 );
253 #[cfg(feature = "v1_20")]
254 check_serialize!(crate::SerializeFlags::all(), "\"backward-compat\"");
255 check_serialize!(crate::StackTraceFlags::all(), "\"full\"");
256 check_serialize!(crate::StreamFlags::all(), "\"sparse+select+unselect\"");
257 check_serialize!(
258 crate::StreamType::all(),
259 "\"unknown+audio+video+container+text\""
260 );
261 }
262
263 #[test]
264 fn test_deserialize() {
265 crate::init().unwrap();
266
267 check_deserialize!(crate::BinFlags, crate::BinFlags::empty(), "\"\"");
268 check_deserialize!(
269 crate::BinFlags,
270 crate::BinFlags::all(),
271 "\"no-resync+streams-aware\""
272 );
273 check_deserialize!(
274 crate::BufferCopyFlags,
275 crate::BufferCopyFlags::all(),
276 "\"flags+timestamps+meta+memory+merge+deep\""
277 );
278 check_deserialize!(
279 crate::BufferFlags,
280 crate::BufferFlags::all(),
281 concat!(
282 "\"live+decode-only+discont+resync+corrupted+marker+header+gap",
283 "+droppable+delta-unit+tag-memory+sync-after+non-droppable\""
284 )
285 );
286 check_deserialize!(
287 crate::BufferPoolAcquireFlags,
288 crate::BufferPoolAcquireFlags::all(),
289 "\"key-unit+dontwait+discont\""
290 );
291 check_deserialize!(
292 crate::ClockFlags,
293 crate::ClockFlags::all(),
294 concat!(
295 "\"can-do-single-sync+can-do-single-async",
296 "+can-do-periodic-sync+can-do-periodic-async",
297 "+can-set-resolution+can-set-master+needs-startup-sync\""
298 )
299 );
300
301 check_deserialize!(
302 crate::DebugColorFlags,
303 crate::DebugColorFlags::all(),
304 "\"fg-white+bg-white+bold+underline\""
305 );
306 check_deserialize!(
307 crate::DebugColorFlags,
308 crate::DebugColorFlags::FG_MAGENTA | crate::DebugColorFlags::BOLD,
309 "\"fg-magenta+bg-black+bold\""
310 );
311 check_deserialize!(
312 crate::DebugColorFlags,
313 crate::DebugColorFlags::FG_RED
314 | crate::DebugColorFlags::FG_BLUE
315 | crate::DebugColorFlags::BG_BLACK,
316 "\"fg-magenta+bg-black\""
317 );
318
319 check_deserialize!(
320 crate::DebugGraphDetails,
321 crate::DebugGraphDetails::all(),
322 "\"verbose\""
323 );
324 check_deserialize!(
325 crate::DebugGraphDetails,
326 crate::DebugGraphDetails::MEDIA_TYPE
327 | crate::DebugGraphDetails::CAPS_DETAILS
328 | crate::DebugGraphDetails::NON_DEFAULT_PARAMS
329 | crate::DebugGraphDetails::STATES
330 | crate::DebugGraphDetails::FULL_PARAMS
331 | crate::DebugGraphDetails::ALL,
332 "\"all+full-params\""
333 );
334 check_deserialize!(
335 crate::DebugGraphDetails,
336 crate::DebugGraphDetails::MEDIA_TYPE
337 | crate::DebugGraphDetails::CAPS_DETAILS
338 | crate::DebugGraphDetails::NON_DEFAULT_PARAMS
339 | crate::DebugGraphDetails::STATES
340 | crate::DebugGraphDetails::FULL_PARAMS,
341 "\"all+full-params\""
342 );
343
344 check_deserialize!(
345 crate::ElementFlags,
346 crate::ElementFlags::all(),
347 "\"locked-state+sink+source+provide-clock+require-clock+indexable\""
348 );
349 check_deserialize!(
350 crate::EventTypeFlags,
351 crate::EventTypeFlags::all(),
352 "\"upstream+downstream+serialized+sticky+sticky-multi\""
353 );
354 #[cfg(feature = "v1_20")]
355 check_deserialize!(crate::GapFlags, crate::GapFlags::all(), "\"data\"");
356 check_deserialize!(
357 crate::MemoryFlags,
358 crate::MemoryFlags::all(),
359 concat!(
360 "\"readonly+no-share+zero-prefixed+zero-padded",
361 "+physically-contiguous+not-mappable\""
362 )
363 );
364 check_deserialize!(
365 crate::MetaFlags,
366 crate::MetaFlags::all(),
367 "\"readonly+pooled+locked\""
368 );
369 check_deserialize!(
370 crate::ObjectFlags,
371 crate::ObjectFlags::all(),
372 "\"may-be-leaked+constructed\""
373 );
374 check_deserialize!(
375 crate::PadFlags,
376 crate::PadFlags::all(),
377 concat!(
378 "\"blocked+flushing+eos+blocking+need-parent+need-reconfigure",
379 "+pending-events+fixed-caps+proxy-caps+proxy-allocation",
380 "+proxy-scheduling+accept-intersect+accept-template\""
381 )
382 );
383 check_deserialize!(
384 crate::PadLinkCheck,
385 crate::PadLinkCheck::all(),
386 "\"hierarchy+template-caps+caps+no-reconfigure\""
387 );
388 check_deserialize!(
389 crate::PadProbeType,
390 crate::PadProbeType::all(),
391 concat!(
392 "\"idle+block+buffer+buffer-list+event-downstream",
393 "+event-upstream+event-flush+query-downstream+query-upstream",
394 "+push+pull\""
395 )
396 );
397 check_deserialize!(
398 crate::ParseFlags,
399 crate::ParseFlags::all(),
400 "\"fatal-errors+no-single-element-bins+place-in-bin\""
401 );
402 #[cfg(feature = "v1_18")]
403 check_deserialize!(
404 crate::PluginAPIFlags,
405 crate::PluginAPIFlags::all(),
406 "\"members\""
407 );
408 check_deserialize!(
409 crate::PluginDependencyFlags,
410 crate::PluginDependencyFlags::all(),
411 concat!(
412 "\"recurse+paths-are-default-only+file-name-is-suffix",
413 "+file-name-is-prefix+paths-are-relative-to-exe\""
414 )
415 );
416 check_deserialize!(
417 crate::PluginFlags,
418 crate::PluginFlags::all(),
419 "\"cached+blacklisted\""
420 );
421 check_deserialize!(
422 crate::SchedulingFlags,
423 crate::SchedulingFlags::all(),
424 "\"seekable+sequential+bandwidth-limited\""
425 );
426 #[cfg(feature = "v1_18")]
427 check_deserialize!(
428 crate::SeekFlags,
429 crate::SeekFlags::all(),
430 concat!(
431 "\"flush+accurate+key-unit+segment+trickmode+snap-before",
432 "+snap-after+trickmode-key-units+trickmode-no-audio",
433 "+trickmode-forward-predicted+instant-rate-change\""
434 )
435 );
436 #[cfg(feature = "v1_18")]
437 check_deserialize!(
438 crate::SegmentFlags,
439 crate::SegmentFlags::all(),
440 concat!(
441 "\"reset+trickmode+segment+trickmode-key-units",
442 "+trickmode-forward-predicted+trickmode-no-audio\""
443 )
444 );
445 #[cfg(feature = "v1_20")]
446 check_deserialize!(
447 crate::SerializeFlags,
448 crate::SerializeFlags::all(),
449 "\"backward-compat\""
450 );
451 check_deserialize!(
452 crate::StackTraceFlags,
453 crate::StackTraceFlags::all(),
454 "\"full\""
455 );
456 check_deserialize!(
457 crate::StreamFlags,
458 crate::StreamFlags::all(),
459 "\"sparse+select+unselect\""
460 );
461 check_deserialize!(
462 crate::StreamType,
463 crate::StreamType::all(),
464 "\"unknown+audio+video+container+text\""
465 );
466 }
467
468 #[test]
469 fn test_serde_roundtrip() {
470 crate::init().unwrap();
471
472 check_roundtrip!(crate::BinFlags, crate::BinFlags::empty());
473 check_roundtrip!(crate::BinFlags, crate::BinFlags::all());
474 check_roundtrip!(crate::BufferCopyFlags, crate::BufferCopyFlags::all());
475 check_roundtrip!(crate::BufferFlags, crate::BufferFlags::all());
476 check_roundtrip!(
477 crate::BufferPoolAcquireFlags,
478 crate::BufferPoolAcquireFlags::all()
479 );
480 check_roundtrip!(crate::ClockFlags, crate::ClockFlags::all());
481
482 check_roundtrip!(crate::DebugColorFlags, crate::DebugColorFlags::all());
483 check_roundtrip!(
484 crate::DebugColorFlags,
485 crate::DebugColorFlags::FG_MAGENTA | crate::DebugColorFlags::BOLD
486 );
487 check_roundtrip!(
488 crate::DebugColorFlags,
489 crate::DebugColorFlags::FG_RED
490 | crate::DebugColorFlags::FG_BLUE
491 | crate::DebugColorFlags::BG_BLACK
492 );
493
494 check_roundtrip!(crate::DebugGraphDetails, crate::DebugGraphDetails::all());
495 check_roundtrip!(
496 crate::DebugGraphDetails,
497 crate::DebugGraphDetails::MEDIA_TYPE
498 | crate::DebugGraphDetails::CAPS_DETAILS
499 | crate::DebugGraphDetails::NON_DEFAULT_PARAMS
500 | crate::DebugGraphDetails::STATES
501 | crate::DebugGraphDetails::FULL_PARAMS
502 | crate::DebugGraphDetails::ALL
503 );
504 check_roundtrip!(
505 crate::DebugGraphDetails,
506 crate::DebugGraphDetails::MEDIA_TYPE
507 | crate::DebugGraphDetails::CAPS_DETAILS
508 | crate::DebugGraphDetails::NON_DEFAULT_PARAMS
509 | crate::DebugGraphDetails::STATES
510 | crate::DebugGraphDetails::FULL_PARAMS
511 );
512
513 check_roundtrip!(crate::ElementFlags, crate::ElementFlags::all());
514 check_roundtrip!(crate::EventTypeFlags, crate::EventTypeFlags::all());
515 #[cfg(feature = "v1_20")]
516 check_roundtrip!(crate::GapFlags, crate::GapFlags::all());
517 check_roundtrip!(crate::MemoryFlags, crate::MemoryFlags::all());
518 check_roundtrip!(crate::MetaFlags, crate::MetaFlags::all());
519 check_roundtrip!(crate::ObjectFlags, crate::ObjectFlags::all());
520 check_roundtrip!(crate::PadFlags, crate::PadFlags::all());
521 check_roundtrip!(crate::PadLinkCheck, crate::PadLinkCheck::all());
522 check_roundtrip!(crate::PadProbeType, crate::PadProbeType::all());
523 check_roundtrip!(crate::ParseFlags, crate::ParseFlags::all());
524 #[cfg(feature = "v1_18")]
525 check_roundtrip!(crate::PluginAPIFlags, crate::PluginAPIFlags::all());
526 check_roundtrip!(
527 crate::PluginDependencyFlags,
528 crate::PluginDependencyFlags::all()
529 );
530 check_roundtrip!(crate::PluginFlags, crate::PluginFlags::all());
531 check_roundtrip!(crate::SchedulingFlags, crate::SchedulingFlags::all());
532 #[cfg(feature = "v1_18")]
533 check_roundtrip!(crate::SeekFlags, crate::SeekFlags::all());
534 #[cfg(feature = "v1_18")]
535 check_roundtrip!(crate::SegmentFlags, crate::SegmentFlags::all());
536 #[cfg(feature = "v1_20")]
537 check_roundtrip!(crate::SerializeFlags, crate::SerializeFlags::all());
538 check_roundtrip!(crate::StackTraceFlags, crate::StackTraceFlags::all());
539 check_roundtrip!(crate::StreamFlags, crate::StreamFlags::all());
540 check_roundtrip!(crate::StreamType, crate::StreamType::all());
541 }
542}