Skip to main content

vmix_core/
models.rs

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    // 属性
153    #[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    // 子要素
214    #[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    // 子要素
290    #[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    // 属性
300    #[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
379// Custom deserializer for XML boolean values
380mod 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
410// Custom deserializer for optional XML boolean values
411mod 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// Outputs structure
450#[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// Mix structure
475#[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// Crop structure for inputs
486#[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}