1use serde::{Deserialize, Serialize};
2
3#[cfg(not(feature = "std"))]
4use alloc::{string::String, vec::Vec};
5
6#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
7pub struct Vmix {
8 #[serde(rename = "version")]
9 pub version: String,
10
11 #[serde(rename = "edition")]
12 pub edition: String,
13
14 #[serde(rename = "preset", default)]
15 pub preset: Option<String>,
16
17 #[serde(rename = "inputs")]
18 pub inputs: Inputs,
19
20 #[serde(rename = "outputs", default)]
21 pub outputs: Option<Outputs>,
22
23 #[serde(rename = "overlays")]
24 pub overlays: Overlays,
25
26 #[serde(rename = "preview")]
27 pub preview: String,
28
29 #[serde(rename = "active")]
30 pub active: String,
31
32 #[serde(rename = "fadeToBlack", with = "xml_bool")]
33 pub fade_to_black: bool,
34
35 #[serde(rename = "transitions")]
36 pub transitions: Transitions,
37
38 #[serde(rename = "recording", with = "xml_bool")]
39 pub recording: bool,
40
41 #[serde(rename = "external", with = "xml_bool")]
42 pub external: bool,
43
44 #[serde(rename = "streaming", with = "xml_bool")]
45 pub streaming: bool,
46
47 #[serde(rename = "playList", with = "xml_bool")]
48 pub play_list: bool,
49
50 #[serde(rename = "multiCorder", with = "xml_bool")]
51 pub multi_corder: bool,
52
53 #[serde(rename = "fullscreen", with = "xml_bool")]
54 pub fullscreen: bool,
55
56 #[serde(rename = "mix", default)]
57 pub mix: Vec<Mix>,
58
59 #[serde(rename = "audio")]
60 pub audio: Audio,
61
62 #[serde(rename = "dynamic")]
63 pub dynamic: Dynamic,
64}
65
66#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
67pub struct Audio {
68 #[serde(rename = "master")]
69 pub master: AudioBus,
70
71 #[serde(rename = "busA", default)]
72 pub bus_a: Option<AudioBus>,
73
74 #[serde(rename = "busB", default)]
75 pub bus_b: Option<AudioBus>,
76
77 #[serde(rename = "busC", default)]
78 pub bus_c: Option<AudioBus>,
79
80 #[serde(rename = "busD", default)]
81 pub bus_d: Option<AudioBus>,
82
83 #[serde(rename = "busE", default)]
84 pub bus_e: Option<AudioBus>,
85
86 #[serde(rename = "busF", default)]
87 pub bus_f: Option<AudioBus>,
88
89 #[serde(rename = "busG", default)]
90 pub bus_g: Option<AudioBus>,
91}
92
93#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
94pub struct AudioBus {
95 #[serde(rename = "@volume")]
96 pub volume: f64,
97
98 #[serde(rename = "@muted", with = "xml_bool")]
99 pub muted: bool,
100
101 #[serde(rename = "@meterF1")]
102 pub meter_f1: f64,
103
104 #[serde(rename = "@meterF2")]
105 pub meter_f2: f64,
106
107 #[serde(rename = "@headphonesVolume", default)]
108 pub headphones_volume: Option<f64>,
109
110 #[serde(rename = "@solo", default, with = "xml_bool_option")]
111 pub solo: Option<bool>,
112
113 #[serde(rename = "@sendToMaster", default, with = "xml_bool_option")]
114 pub send_to_master: Option<bool>,
115}
116
117#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
118pub struct Dynamic {
119 #[serde(rename = "input1")]
120 pub input1: String,
121
122 #[serde(rename = "input2")]
123 pub input2: String,
124
125 #[serde(rename = "input3")]
126 pub input3: String,
127
128 #[serde(rename = "input4")]
129 pub input4: String,
130
131 #[serde(rename = "value1")]
132 pub value1: String,
133
134 #[serde(rename = "value2")]
135 pub value2: String,
136
137 #[serde(rename = "value3")]
138 pub value3: String,
139
140 #[serde(rename = "value4")]
141 pub value4: String,
142}
143
144#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
145pub struct Inputs {
146 #[serde(rename = "input")]
147 pub input: Vec<Input>,
148}
149
150#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
151pub struct Input {
152 #[serde(rename = "@key")]
154 pub key: String,
155
156 #[serde(rename = "@number")]
157 pub number: String,
158
159 #[serde(rename = "@type")]
160 pub input_type: String,
161
162 #[serde(rename = "@title")]
163 pub title: String,
164
165 #[serde(rename = "@shortTitle")]
166 pub short_title: String,
167
168 #[serde(rename = "@state")]
169 pub state: State,
170
171 #[serde(rename = "@position")]
172 pub position: String,
173
174 #[serde(rename = "@duration")]
175 pub duration: String,
176
177 #[serde(rename = "@loop", with = "xml_bool")]
178 pub input_loop: bool,
179
180 #[serde(rename = "@muted", default, with = "xml_bool_option")]
181 pub muted: Option<bool>,
182
183 #[serde(rename = "@volume", default)]
184 pub volume: Option<f64>,
185
186 #[serde(rename = "@balance", default)]
187 pub balance: Option<f64>,
188
189 #[serde(rename = "@solo", default, with = "xml_bool_option")]
190 pub solo: Option<bool>,
191
192 #[serde(rename = "@soloPFL", default, with = "xml_bool_option")]
193 pub solo_pfl: Option<bool>,
194
195 #[serde(rename = "@audiobusses", default)]
196 pub audiobusses: Option<String>,
197
198 #[serde(rename = "@meterF1", default)]
199 pub meter_f1: Option<f64>,
200
201 #[serde(rename = "@meterF2", default)]
202 pub meter_f2: Option<f64>,
203
204 #[serde(rename = "@gainDb", default)]
205 pub gain_db: Option<f64>,
206
207 #[serde(rename = "@selectedIndex", default)]
208 pub selected_index: Option<String>,
209
210 #[serde(rename = "@preset", default)]
211 pub preset: Option<String>,
212
213 #[serde(rename = "list", default)]
215 pub list: Option<List>,
216
217 #[serde(rename = "image", default)]
218 pub image: Vec<Image>,
219
220 #[serde(rename = "replay", default)]
221 pub replay: Option<Replay>,
222
223 #[serde(rename = "overlay", default)]
224 pub overlay: Vec<InputOverlay>,
225
226 #[serde(rename = "crop", default)]
227 pub crop: Option<Crop>,
228
229 #[serde(rename = "position", default)]
230 pub input_position: Option<Position>,
231}
232
233#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
234pub struct Image {
235 #[serde(rename = "index", default)]
236 pub index: Option<String>,
237
238 #[serde(rename = "name", default)]
239 pub name: Option<String>,
240}
241
242#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
243pub struct List {
244 #[serde(rename = "item", default)]
245 pub item: Vec<ListItem>,
246}
247
248#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
249pub struct InputOverlay {
250 #[serde(rename = "@index")]
251 pub index: String,
252
253 #[serde(rename = "@key")]
254 pub key: String,
255
256 #[serde(rename = "position", default)]
257 pub position: Option<Position>,
258}
259
260#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
261pub struct Position {
262 #[serde(rename = "@panX", default)]
263 pub pan_x: Option<String>,
264
265 #[serde(rename = "@panY", default)]
266 pub pan_y: Option<String>,
267
268 #[serde(rename = "@zoomX", default)]
269 pub zoom_x: Option<String>,
270
271 #[serde(rename = "@zoomY", default)]
272 pub zoom_y: Option<String>,
273
274 #[serde(rename = "@x", default)]
275 pub x: Option<String>,
276
277 #[serde(rename = "@y", default)]
278 pub y: Option<String>,
279
280 #[serde(rename = "@width", default)]
281 pub width: Option<String>,
282
283 #[serde(rename = "@height", default)]
284 pub height: Option<String>,
285}
286
287#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
288pub struct Replay {
289 #[serde(rename = "timecode", default)]
291 pub timecode: String,
292
293 #[serde(rename = "timecodeA", default)]
294 pub timecode_a: String,
295
296 #[serde(rename = "timecodeB", default)]
297 pub timecode_b: String,
298
299 #[serde(rename = "@live", default)]
301 pub live: Option<String>,
302
303 #[serde(rename = "@recording", default)]
304 pub recording: Option<String>,
305
306 #[serde(rename = "@channelMode", default)]
307 pub channel_mode: String,
308
309 #[serde(rename = "@events", default)]
310 pub events: String,
311
312 #[serde(rename = "@eventsA", default)]
313 pub events_a: String,
314
315 #[serde(rename = "@eventsB", default)]
316 pub events_b: String,
317
318 #[serde(rename = "@cameraA", default)]
319 pub camera_a: String,
320
321 #[serde(rename = "@cameraB", default)]
322 pub camera_b: String,
323
324 #[serde(rename = "@speed", default)]
325 pub speed: String,
326
327 #[serde(rename = "@speedA", default)]
328 pub speed_a: String,
329
330 #[serde(rename = "@speedB", default)]
331 pub speed_b: String,
332}
333
334#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
335pub struct Overlays {
336 #[serde(rename = "overlay")]
337 pub overlay: Vec<OverlaysOverlay>,
338}
339
340#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
341pub struct OverlaysOverlay {
342 #[serde(rename = "@number")]
343 pub number: String,
344
345 #[serde(rename = "$value", default)]
346 pub input: Option<String>,
347}
348
349#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
350pub struct Transitions {
351 #[serde(rename = "transition")]
352 pub transition: Vec<Transition>,
353}
354
355#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
356pub struct Transition {
357 #[serde(rename = "@number")]
358 pub number: String,
359
360 #[serde(rename = "@effect")]
361 pub effect: String,
362
363 #[serde(rename = "@duration")]
364 pub duration: String,
365}
366
367#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
368pub struct ListItem {
369 #[serde(rename = "@enabled", default)]
370 pub enabled: Option<String>,
371 #[serde(rename = "@selected", default)]
372 pub selected: Option<String>,
373 #[serde(rename = "@index", default)]
374 pub index: Option<String>,
375 #[serde(rename = "$value", default)]
376 pub text: Option<String>,
377}
378
379mod xml_bool {
381 use serde::{Deserialize, Deserializer, Serializer};
382
383 #[cfg(not(feature = "std"))]
384 use alloc::{format, string::String};
385
386 pub fn serialize<S>(value: &bool, serializer: S) -> Result<S::Ok, S::Error>
387 where
388 S: Serializer,
389 {
390 let s = if *value { "True" } else { "False" };
391 serializer.serialize_str(s)
392 }
393
394 pub fn deserialize<'de, D>(deserializer: D) -> Result<bool, D::Error>
395 where
396 D: Deserializer<'de>,
397 {
398 let s = String::deserialize(deserializer)?;
399 match s.as_str() {
400 "True" => Ok(true),
401 "False" => Ok(false),
402 _ => Err(serde::de::Error::custom(format!(
403 "Invalid boolean value: {}",
404 s
405 ))),
406 }
407 }
408}
409
410mod xml_bool_option {
412 use serde::{Deserialize, Deserializer, Serializer};
413
414 #[cfg(not(feature = "std"))]
415 use alloc::{format, string::String};
416
417 pub fn serialize<S>(value: &Option<bool>, serializer: S) -> Result<S::Ok, S::Error>
418 where
419 S: Serializer,
420 {
421 match value {
422 Some(b) => {
423 let s = if *b { "True" } else { "False" };
424 serializer.serialize_str(s)
425 }
426 None => serializer.serialize_none(),
427 }
428 }
429
430 pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<bool>, D::Error>
431 where
432 D: Deserializer<'de>,
433 {
434 let opt = Option::<String>::deserialize(deserializer)?;
435 match opt {
436 Some(s) => match s.as_str() {
437 "True" => Ok(Some(true)),
438 "False" => Ok(Some(false)),
439 _ => Err(serde::de::Error::custom(format!(
440 "Invalid boolean value: {}",
441 s
442 ))),
443 },
444 None => Ok(None),
445 }
446 }
447}
448
449#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
451pub struct Outputs {
452 #[serde(rename = "output", default)]
453 pub output: Vec<Output>,
454}
455
456#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
457pub struct Output {
458 #[serde(rename = "@type")]
459 pub output_type: String,
460 #[serde(rename = "@number")]
461 pub number: String,
462 #[serde(rename = "@source")]
463 pub source: String,
464 #[serde(rename = "@external", default)]
465 pub external: Option<String>,
466 #[serde(rename = "@ndi", default)]
467 pub ndi: Option<String>,
468 #[serde(rename = "@mix", default)]
469 pub mix: Option<String>,
470 #[serde(rename = "@inputNumber", default)]
471 pub input_number: Option<String>,
472}
473
474#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
476pub struct Mix {
477 #[serde(rename = "@number")]
478 pub number: String,
479 #[serde(rename = "preview")]
480 pub preview: String,
481 #[serde(rename = "active")]
482 pub active: String,
483}
484
485#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
487pub struct Crop {
488 #[serde(rename = "@X1")]
489 pub x1: String,
490 #[serde(rename = "@Y1")]
491 pub y1: String,
492 #[serde(rename = "@X2")]
493 pub x2: String,
494 #[serde(rename = "@Y2")]
495 pub y2: String,
496}
497
498#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
499pub enum State {
500 #[serde(rename = "Paused")]
501 Paused,
502
503 #[serde(rename = "Running")]
504 Running,
505
506 #[serde(rename = "Completed")]
507 Completed,
508}
509
510#[cfg(all(test, feature = "xml"))]
511mod overlay_tests {
512 use super::*;
513 use quick_xml::de::from_str;
514
515 #[test]
516 fn parses_overlays_1_through_8_with_active_input() {
517 let xml = r#"<overlays>
518 <overlay number="1" />
519 <overlay number="2" />
520 <overlay number="3" />
521 <overlay number="4" />
522 <overlay number="5">2</overlay>
523 <overlay number="6" />
524 <overlay number="7" />
525 <overlay number="8">5</overlay>
526 </overlays>"#;
527
528 let overlays: Overlays = from_str(xml).expect("overlays should parse");
529 assert_eq!(overlays.overlay.len(), 8);
530 assert_eq!(overlays.overlay[0].number, "1");
531 assert!(
532 overlays.overlay[0]
533 .input
534 .as_deref()
535 .unwrap_or("")
536 .is_empty()
537 );
538 assert_eq!(overlays.overlay[4].number, "5");
539 assert_eq!(overlays.overlay[4].input.as_deref(), Some("2"));
540 assert_eq!(overlays.overlay[7].number, "8");
541 assert_eq!(overlays.overlay[7].input.as_deref(), Some("5"));
542 }
543}