maolan_engine/
message.rs

1use crate::clap::{ClapParameterInfo, ClapPluginInfo};
2#[cfg(all(unix, not(target_os = "macos")))]
3use crate::lv2::Lv2PluginInfo;
4use crate::midi::io::MidiEvent;
5use crate::vst3::Vst3PluginInfo;
6use crate::{kind::Kind, mutex::UnsafeMutex, track::Track};
7use std::sync::{Arc, atomic::AtomicBool};
8use tokio::sync::mpsc::Sender;
9
10#[derive(Clone, Debug)]
11pub struct MidiNoteData {
12    pub start_sample: usize,
13    pub length_samples: usize,
14    pub pitch: u8,
15    pub velocity: u8,
16    pub channel: u8,
17}
18
19#[derive(Clone, Debug)]
20pub struct MidiControllerData {
21    pub sample: usize,
22    pub controller: u8,
23    pub value: u8,
24    pub channel: u8,
25}
26
27#[derive(Debug, Clone)]
28pub struct MidiRawEventData {
29    pub sample: usize,
30    pub data: Vec<u8>,
31}
32
33#[derive(Clone, Debug)]
34pub struct HwMidiEvent {
35    pub device: String,
36    pub event: MidiEvent,
37}
38
39#[derive(Clone, Debug)]
40pub struct OfflineAutomationPoint {
41    pub sample: usize,
42    pub value: f32,
43}
44
45#[derive(Clone, Debug)]
46pub enum OfflineAutomationTarget {
47    Volume,
48    Balance,
49    Mute,
50    #[cfg(all(unix, not(target_os = "macos")))]
51    Lv2Parameter {
52        instance_id: usize,
53        index: u32,
54        min: f32,
55        max: f32,
56    },
57    Vst3Parameter {
58        instance_id: usize,
59        param_id: u32,
60    },
61    ClapParameter {
62        instance_id: usize,
63        param_id: u32,
64        min: f64,
65        max: f64,
66    },
67}
68
69#[derive(Clone, Debug)]
70pub struct OfflineAutomationLane {
71    pub target: OfflineAutomationTarget,
72    pub points: Vec<OfflineAutomationPoint>,
73}
74
75#[derive(Clone, Debug)]
76pub struct OfflineBounceWork {
77    pub state: Arc<UnsafeMutex<crate::state::State>>,
78    pub track_name: String,
79    pub output_path: String,
80    pub start_sample: usize,
81    pub length_samples: usize,
82    pub tempo_bpm: f64,
83    pub tsig_num: u16,
84    pub tsig_denom: u16,
85    pub automation_lanes: Vec<OfflineAutomationLane>,
86    pub cancel: Arc<AtomicBool>,
87}
88
89#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
90pub struct PitchCorrectionPointData {
91    pub start_sample: usize,
92    pub length_samples: usize,
93    pub detected_midi_pitch: f32,
94    pub target_midi_pitch: f32,
95    pub clarity: f32,
96}
97
98#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
99pub struct AudioClipData {
100    pub name: String,
101    pub start: usize,
102    pub length: usize,
103    pub offset: usize,
104    pub input_channel: usize,
105    pub muted: bool,
106    pub peaks_file: Option<String>,
107    pub fade_enabled: bool,
108    pub fade_in_samples: usize,
109    pub fade_out_samples: usize,
110    pub preview_name: Option<String>,
111    pub source_name: Option<String>,
112    pub source_offset: Option<usize>,
113    pub source_length: Option<usize>,
114    pub pitch_correction_points: Vec<PitchCorrectionPointData>,
115    pub pitch_correction_frame_likeness: Option<f32>,
116    pub pitch_correction_inertia_ms: Option<u16>,
117    pub pitch_correction_formant_compensation: Option<bool>,
118    pub plugin_graph_json: Option<serde_json::Value>,
119    pub grouped_clips: Vec<AudioClipData>,
120}
121
122#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
123pub struct MidiClipData {
124    pub name: String,
125    pub start: usize,
126    pub length: usize,
127    pub offset: usize,
128    pub input_channel: usize,
129    pub muted: bool,
130    pub grouped_clips: Vec<MidiClipData>,
131}
132
133#[derive(Clone, Debug)]
134pub struct ClipMoveFrom {
135    pub track_name: String,
136    pub clip_index: usize,
137}
138
139#[derive(Clone, Debug)]
140pub struct ClipMoveTo {
141    pub track_name: String,
142    pub sample_offset: usize,
143    pub input_channel: usize,
144}
145
146#[cfg(unix)]
147#[derive(Clone, Debug, PartialEq, Eq, Hash)]
148pub enum PluginGraphNode {
149    TrackInput,
150    TrackOutput,
151    Lv2PluginInstance(usize),
152    Vst3PluginInstance(usize),
153    ClapPluginInstance(usize),
154}
155
156#[cfg(unix)]
157#[derive(Clone, Debug, PartialEq)]
158pub struct PluginGraphPlugin {
159    pub node: PluginGraphNode,
160    pub instance_id: usize,
161    pub format: String,
162    pub uri: String,
163    pub plugin_id: String,
164    pub name: String,
165    pub main_audio_inputs: usize,
166    pub main_audio_outputs: usize,
167    pub audio_inputs: usize,
168    pub audio_outputs: usize,
169    pub midi_inputs: usize,
170    pub midi_outputs: usize,
171    pub state: Option<serde_json::Value>,
172}
173
174#[cfg(unix)]
175#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
176pub struct Lv2StatePortValue {
177    pub index: u32,
178    pub value: f32,
179}
180
181#[cfg(unix)]
182#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
183pub struct Lv2StateProperty {
184    pub key_uri: String,
185    pub type_uri: String,
186    pub flags: u32,
187    pub value: Vec<u8>,
188}
189
190#[cfg(unix)]
191#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
192pub struct Lv2PluginState {
193    pub port_values: Vec<Lv2StatePortValue>,
194    pub properties: Vec<Lv2StateProperty>,
195}
196
197#[cfg(all(unix, not(target_os = "macos")))]
198#[derive(Clone, Debug, PartialEq)]
199pub struct Lv2ControlPortInfo {
200    pub index: u32,
201    pub name: String,
202    pub min: f32,
203    pub max: f32,
204    pub value: f32,
205}
206
207#[cfg(unix)]
208#[derive(Clone, Debug, PartialEq, Eq)]
209pub struct PluginGraphConnection {
210    pub from_node: PluginGraphNode,
211    pub from_port: usize,
212    pub to_node: PluginGraphNode,
213    pub to_port: usize,
214    pub kind: Kind,
215}
216
217#[cfg(unix)]
218pub type PluginGraphSnapshot = (Vec<PluginGraphPlugin>, Vec<PluginGraphConnection>);
219
220// VST3 graph types
221#[derive(Clone, Debug, PartialEq, Eq, Hash)]
222pub enum Vst3GraphNode {
223    TrackInput,
224    TrackOutput,
225    PluginInstance(usize),
226}
227
228#[derive(Clone, Debug)]
229pub struct Vst3GraphPlugin {
230    pub instance_id: usize,
231    pub name: String,
232    pub path: String,
233    pub audio_inputs: usize,
234    pub audio_outputs: usize,
235    pub parameters: Vec<crate::vst3::port::ParameterInfo>,
236}
237
238#[derive(Clone, Debug, PartialEq, Eq)]
239pub struct Vst3GraphConnection {
240    pub from_node: Vst3GraphNode,
241    pub from_port: usize,
242    pub to_node: Vst3GraphNode,
243    pub to_port: usize,
244    pub kind: Kind,
245}
246
247#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
248pub struct MidiLearnBinding {
249    pub device: Option<String>,
250    pub channel: u8,
251    pub cc: u8,
252}
253
254#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
255pub enum TrackMidiLearnTarget {
256    Volume,
257    Balance,
258    Mute,
259    Solo,
260    Arm,
261    InputMonitor,
262    DiskMonitor,
263}
264
265#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
266pub enum GlobalMidiLearnTarget {
267    PlayPause,
268    Stop,
269    RecordToggle,
270}
271
272#[derive(Clone, Debug)]
273pub enum Action {
274    Quit,
275    Play,
276    Pause,
277    Stop,
278    TransportPosition(usize),
279    JumpToEnd,
280    SetLoopEnabled(bool),
281    SetLoopRange(Option<(usize, usize)>),
282    SetPunchEnabled(bool),
283    SetPunchRange(Option<(usize, usize)>),
284    SetMetronomeEnabled(bool),
285    SetTempo(f64),
286    SetTimeSignature {
287        numerator: u16,
288        denominator: u16,
289    },
290    SetOscEnabled(bool),
291    SetClipPlaybackEnabled(bool),
292    SetRecordEnabled(bool),
293    SetSessionPath(String),
294    BeginHistoryGroup,
295    EndHistoryGroup,
296    ClearHistory,
297    BeginSessionRestore,
298    EndSessionRestore,
299    AddTrack {
300        name: String,
301        audio_ins: usize,
302        midi_ins: usize,
303        audio_outs: usize,
304        midi_outs: usize,
305    },
306    TrackAddAudioInput(String),
307    TrackAddAudioOutput(String),
308    TrackRemoveAudioInput(String),
309    TrackRemoveAudioOutput(String),
310    AddClip {
311        name: String,
312        track_name: String,
313        start: usize,
314        length: usize,
315        offset: usize,
316        input_channel: usize,
317        muted: bool,
318        peaks_file: Option<String>,
319        kind: Kind,
320        fade_enabled: bool,
321        fade_in_samples: usize,
322        fade_out_samples: usize,
323        source_name: Option<String>,
324        source_offset: Option<usize>,
325        source_length: Option<usize>,
326        preview_name: Option<String>,
327        pitch_correction_points: Vec<PitchCorrectionPointData>,
328        pitch_correction_frame_likeness: Option<f32>,
329        pitch_correction_inertia_ms: Option<u16>,
330        pitch_correction_formant_compensation: Option<bool>,
331        plugin_graph_json: Option<serde_json::Value>,
332    },
333    AddGroupedClip {
334        track_name: String,
335        kind: Kind,
336        audio_clip: Option<AudioClipData>,
337        midi_clip: Option<MidiClipData>,
338    },
339    RemoveClip {
340        track_name: String,
341        kind: Kind,
342        clip_indices: Vec<usize>,
343    },
344    SetClipFade {
345        track_name: String,
346        clip_index: usize,
347        kind: Kind,
348        fade_enabled: bool,
349        fade_in_samples: usize,
350        fade_out_samples: usize,
351    },
352    SetClipBounds {
353        track_name: String,
354        clip_index: usize,
355        kind: Kind,
356        start: usize,
357        length: usize,
358        offset: usize,
359    },
360    SetClipMuted {
361        track_name: String,
362        clip_index: usize,
363        kind: Kind,
364        muted: bool,
365    },
366    SetClipPluginGraphJson {
367        track_name: String,
368        clip_index: usize,
369        plugin_graph_json: Option<serde_json::Value>,
370    },
371    SetClipPitchCorrection {
372        track_name: String,
373        clip_index: usize,
374        preview_name: Option<String>,
375        source_name: Option<String>,
376        source_offset: Option<usize>,
377        source_length: Option<usize>,
378        pitch_correction_points: Vec<PitchCorrectionPointData>,
379        pitch_correction_frame_likeness: Option<f32>,
380        pitch_correction_inertia_ms: Option<u16>,
381        pitch_correction_formant_compensation: Option<bool>,
382    },
383    RenameClip {
384        track_name: String,
385        kind: Kind,
386        clip_index: usize,
387        new_name: String,
388    },
389    RenameTrack {
390        old_name: String,
391        new_name: String,
392    },
393    RemoveTrack(String),
394    TrackLevel(String, f32),
395    TrackBalance(String, f32),
396    TrackAutomationLevel(String, f32),
397    TrackAutomationBalance(String, f32),
398    TrackAutomationMute(String, bool),
399    TrackMeters {
400        track_name: String,
401        output_db: Vec<f32>,
402    },
403    RequestMeterSnapshot,
404    MeterSnapshot {
405        hw_out_db: Arc<Vec<f32>>,
406        track_meters: Arc<Vec<(String, Vec<f32>)>>,
407    },
408    TrackToggleArm(String),
409    TrackToggleMute(String),
410    TrackToggleSolo(String),
411    TrackToggleInputMonitor(String),
412    TrackToggleDiskMonitor(String),
413    TrackArmMidiLearn {
414        track_name: String,
415        target: TrackMidiLearnTarget,
416    },
417    GlobalArmMidiLearn {
418        target: GlobalMidiLearnTarget,
419    },
420    TrackSetMidiLearnBinding {
421        track_name: String,
422        target: TrackMidiLearnTarget,
423        binding: Option<MidiLearnBinding>,
424    },
425    SetGlobalMidiLearnBinding {
426        target: GlobalMidiLearnTarget,
427        binding: Option<MidiLearnBinding>,
428    },
429    TrackSetVcaMaster {
430        track_name: String,
431        master_track: Option<String>,
432    },
433    TrackSetMidiLaneChannel {
434        track_name: String,
435        lane: usize,
436        channel: Option<u8>,
437    },
438    TrackSetFrozen {
439        track_name: String,
440        frozen: bool,
441    },
442    TrackOfflineBounce {
443        track_name: String,
444        output_path: String,
445        start_sample: usize,
446        length_samples: usize,
447        automation_lanes: Vec<OfflineAutomationLane>,
448    },
449    TrackOfflineBounceCancel {
450        track_name: String,
451    },
452    TrackOfflineBounceCanceled {
453        track_name: String,
454    },
455    TrackOfflineBounceProgress {
456        track_name: String,
457        progress: f32,
458        operation: Option<String>,
459    },
460    PianoKey {
461        track_name: String,
462        note: u8,
463        velocity: u8,
464        on: bool,
465    },
466    ModifyMidiNotes {
467        track_name: String,
468        clip_index: usize,
469        note_indices: Vec<usize>,
470        new_notes: Vec<MidiNoteData>,
471        old_notes: Vec<MidiNoteData>,
472    },
473    ModifyMidiControllers {
474        track_name: String,
475        clip_index: usize,
476        controller_indices: Vec<usize>,
477        new_controllers: Vec<MidiControllerData>,
478        old_controllers: Vec<MidiControllerData>,
479    },
480    DeleteMidiControllers {
481        track_name: String,
482        clip_index: usize,
483        controller_indices: Vec<usize>,
484        deleted_controllers: Vec<(usize, MidiControllerData)>,
485    },
486    InsertMidiControllers {
487        track_name: String,
488        clip_index: usize,
489        controllers: Vec<(usize, MidiControllerData)>,
490    },
491    DeleteMidiNotes {
492        track_name: String,
493        clip_index: usize,
494        note_indices: Vec<usize>,
495        deleted_notes: Vec<(usize, MidiNoteData)>,
496    },
497    InsertMidiNotes {
498        track_name: String,
499        clip_index: usize,
500        notes: Vec<(usize, MidiNoteData)>,
501    },
502    SetMidiSysExEvents {
503        track_name: String,
504        clip_index: usize,
505        new_sysex_events: Vec<MidiRawEventData>,
506        old_sysex_events: Vec<MidiRawEventData>,
507    },
508    #[cfg(all(unix, not(target_os = "macos")))]
509    TrackLoadLv2Plugin {
510        track_name: String,
511        plugin_uri: String,
512    },
513    TrackClearDefaultPassthrough {
514        track_name: String,
515    },
516    #[cfg(all(unix, not(target_os = "macos")))]
517    TrackSetLv2PluginState {
518        track_name: String,
519        instance_id: usize,
520        state: Lv2PluginState,
521    },
522    #[cfg(all(unix, not(target_os = "macos")))]
523    ClipSetLv2PluginState {
524        track_name: String,
525        clip_idx: usize,
526        instance_id: usize,
527        state: Lv2PluginState,
528    },
529    #[cfg(all(unix, not(target_os = "macos")))]
530    TrackUnloadLv2PluginInstance {
531        track_name: String,
532        instance_id: usize,
533    },
534    #[cfg(all(unix, not(target_os = "macos")))]
535    TrackGetLv2PluginControls {
536        track_name: String,
537        instance_id: usize,
538    },
539    #[cfg(all(unix, not(target_os = "macos")))]
540    ClipGetLv2PluginControls {
541        track_name: String,
542        clip_idx: usize,
543        instance_id: usize,
544    },
545    #[cfg(all(unix, not(target_os = "macos")))]
546    TrackLv2PluginControls {
547        track_name: String,
548        instance_id: usize,
549        controls: Vec<Lv2ControlPortInfo>,
550        instance_access_handle: Option<usize>,
551    },
552    #[cfg(all(unix, not(target_os = "macos")))]
553    ClipLv2PluginControls {
554        track_name: String,
555        clip_idx: usize,
556        instance_id: usize,
557        controls: Vec<Lv2ControlPortInfo>,
558        instance_access_handle: Option<usize>,
559    },
560    #[cfg(all(unix, not(target_os = "macos")))]
561    TrackGetLv2Midnam {
562        track_name: String,
563    },
564    #[cfg(all(unix, not(target_os = "macos")))]
565    TrackLv2Midnam {
566        track_name: String,
567        note_names: std::collections::HashMap<u8, String>,
568    },
569    #[cfg(all(unix, not(target_os = "macos")))]
570    TrackSetLv2ControlValue {
571        track_name: String,
572        instance_id: usize,
573        index: u32,
574        value: f32,
575    },
576    #[cfg(all(unix, not(target_os = "macos")))]
577    ClipSetLv2ControlValue {
578        track_name: String,
579        clip_idx: usize,
580        instance_id: usize,
581        index: u32,
582        value: f32,
583    },
584    #[cfg(all(unix, not(target_os = "macos")))]
585    ClipLv2StateSnapshot {
586        track_name: String,
587        clip_idx: usize,
588        instance_id: usize,
589        state: Lv2PluginState,
590    },
591    #[cfg(unix)]
592    TrackGetPluginGraph {
593        track_name: String,
594    },
595    #[cfg(unix)]
596    TrackPluginGraph {
597        track_name: String,
598        plugins: Vec<PluginGraphPlugin>,
599        connections: Vec<PluginGraphConnection>,
600    },
601    #[cfg(unix)]
602    TrackConnectPluginAudio {
603        track_name: String,
604        from_node: PluginGraphNode,
605        from_port: usize,
606        to_node: PluginGraphNode,
607        to_port: usize,
608    },
609    #[cfg(unix)]
610    TrackConnectPluginMidi {
611        track_name: String,
612        from_node: PluginGraphNode,
613        from_port: usize,
614        to_node: PluginGraphNode,
615        to_port: usize,
616    },
617    #[cfg(unix)]
618    TrackDisconnectPluginAudio {
619        track_name: String,
620        from_node: PluginGraphNode,
621        from_port: usize,
622        to_node: PluginGraphNode,
623        to_port: usize,
624    },
625    #[cfg(unix)]
626    TrackDisconnectPluginMidi {
627        track_name: String,
628        from_node: PluginGraphNode,
629        from_port: usize,
630        to_node: PluginGraphNode,
631        to_port: usize,
632    },
633    #[cfg(all(unix, not(target_os = "macos")))]
634    ListLv2Plugins,
635    #[cfg(all(unix, not(target_os = "macos")))]
636    Lv2Plugins(Vec<Lv2PluginInfo>),
637    ListVst3Plugins,
638    Vst3Plugins(Vec<Vst3PluginInfo>),
639    ListClapPlugins,
640    ListClapPluginsWithCapabilities,
641    ClapPlugins(Vec<ClapPluginInfo>),
642    TrackLoadClapPlugin {
643        track_name: String,
644        plugin_path: String,
645    },
646    TrackUnloadClapPlugin {
647        track_name: String,
648        plugin_path: String,
649    },
650    TrackSetClapParameter {
651        track_name: String,
652        instance_id: usize,
653        param_id: u32,
654        value: f64,
655    },
656    ClipSetClapParameter {
657        track_name: String,
658        clip_idx: usize,
659        instance_id: usize,
660        param_id: u32,
661        value: f64,
662    },
663    TrackSetClapParameterAt {
664        track_name: String,
665        instance_id: usize,
666        param_id: u32,
667        value: f64,
668        frame: u32,
669    },
670    TrackBeginClapParameterEdit {
671        track_name: String,
672        instance_id: usize,
673        param_id: u32,
674        frame: u32,
675    },
676    TrackEndClapParameterEdit {
677        track_name: String,
678        instance_id: usize,
679        param_id: u32,
680        frame: u32,
681    },
682    TrackGetClapParameters {
683        track_name: String,
684        instance_id: usize,
685    },
686    TrackClapParameters {
687        track_name: String,
688        instance_id: usize,
689        parameters: Vec<ClapParameterInfo>,
690    },
691    TrackClapSnapshotState {
692        track_name: String,
693        instance_id: usize,
694    },
695    ClipClapSnapshotState {
696        track_name: String,
697        clip_idx: usize,
698        instance_id: usize,
699    },
700    TrackClapStateSnapshot {
701        track_name: String,
702        instance_id: usize,
703        plugin_path: String,
704        state: crate::clap::ClapPluginState,
705    },
706    ClipClapStateSnapshot {
707        track_name: String,
708        clip_idx: usize,
709        instance_id: usize,
710        plugin_path: String,
711        state: crate::clap::ClapPluginState,
712    },
713    TrackClapRestoreState {
714        track_name: String,
715        instance_id: usize,
716        state: crate::clap::ClapPluginState,
717    },
718    ClipClapRestoreState {
719        track_name: String,
720        clip_idx: usize,
721        instance_id: usize,
722        state: crate::clap::ClapPluginState,
723    },
724    TrackSnapshotAllClapStates {
725        track_name: String,
726    },
727    TrackSnapshotAllClapStatesDone {
728        track_name: String,
729    },
730    TrackLoadVst3Plugin {
731        track_name: String,
732        plugin_path: String,
733    },
734    TrackUnloadVst3PluginInstance {
735        track_name: String,
736        instance_id: usize,
737    },
738    TrackGetVst3Graph {
739        track_name: String,
740    },
741    TrackVst3Graph {
742        track_name: String,
743        plugins: Vec<Vst3GraphPlugin>,
744        connections: Vec<Vst3GraphConnection>,
745    },
746    TrackSetVst3Parameter {
747        track_name: String,
748        instance_id: usize,
749        param_id: u32,
750        value: f32,
751    },
752    TrackGetVst3Parameters {
753        track_name: String,
754        instance_id: usize,
755    },
756    TrackVst3Parameters {
757        track_name: String,
758        instance_id: usize,
759        parameters: Vec<crate::vst3::port::ParameterInfo>,
760    },
761    TrackVst3SnapshotState {
762        track_name: String,
763        instance_id: usize,
764    },
765    ClipVst3SnapshotState {
766        track_name: String,
767        clip_idx: usize,
768        instance_id: usize,
769    },
770    TrackVst3StateSnapshot {
771        track_name: String,
772        instance_id: usize,
773        state: crate::vst3::state::Vst3PluginState,
774    },
775    ClipVst3StateSnapshot {
776        track_name: String,
777        clip_idx: usize,
778        instance_id: usize,
779        state: crate::vst3::state::Vst3PluginState,
780    },
781    TrackVst3RestoreState {
782        track_name: String,
783        instance_id: usize,
784        state: crate::vst3::state::Vst3PluginState,
785    },
786    TrackConnectVst3Audio {
787        track_name: String,
788        from_node: Vst3GraphNode,
789        from_port: usize,
790        to_node: Vst3GraphNode,
791        to_port: usize,
792    },
793    TrackDisconnectVst3Audio {
794        track_name: String,
795        from_node: Vst3GraphNode,
796        from_port: usize,
797        to_node: Vst3GraphNode,
798        to_port: usize,
799    },
800    ClipMove {
801        kind: Kind,
802        from: ClipMoveFrom,
803        to: ClipMoveTo,
804        copy: bool,
805    },
806    Connect {
807        from_track: String,
808        from_port: usize,
809        to_track: String,
810        to_port: usize,
811        kind: Kind,
812    },
813    Disconnect {
814        from_track: String,
815        from_port: usize,
816        to_track: String,
817        to_port: usize,
818        kind: Kind,
819    },
820    OpenAudioDevice {
821        device: String,
822        input_device: Option<String>,
823        sample_rate_hz: i32,
824        bits: i32,
825        exclusive: bool,
826        period_frames: usize,
827        nperiods: usize,
828        sync_mode: bool,
829    },
830    JackAddAudioInputPort,
831    JackRemoveAudioInputPort(usize),
832    JackAddAudioOutputPort,
833    JackRemoveAudioOutputPort(usize),
834    OpenMidiInputDevice(String),
835    OpenMidiOutputDevice(String),
836    RequestSessionDiagnostics,
837    RequestMidiLearnMappingsReport,
838    ClearAllMidiLearnBindings,
839    SessionDiagnosticsReport {
840        track_count: usize,
841        frozen_track_count: usize,
842        audio_clip_count: usize,
843        midi_clip_count: usize,
844        #[cfg(all(unix, not(target_os = "macos")))]
845        lv2_instance_count: usize,
846        vst3_instance_count: usize,
847        clap_instance_count: usize,
848        pending_requests: usize,
849        workers_total: usize,
850        workers_ready: usize,
851        pending_hw_midi_events: usize,
852        playing: bool,
853        transport_sample: usize,
854        tempo_bpm: f64,
855        sample_rate_hz: usize,
856        cycle_samples: usize,
857    },
858    MidiLearnMappingsReport {
859        lines: Vec<String>,
860    },
861    HWInfo {
862        channels: usize,
863        rate: usize,
864        input: bool,
865    },
866    Undo,
867    Redo,
868    Panic,
869}
870
871#[derive(Clone, Debug)]
872pub enum Message {
873    Ready(usize),
874    Finished {
875        worker_id: usize,
876        track_name: String,
877        output_linear: Vec<f32>,
878        process_epoch: usize,
879    },
880    TracksFinished,
881
882    ProcessTrack(Arc<UnsafeMutex<Box<Track>>>),
883    ProcessOfflineBounce(OfflineBounceWork),
884    Channel(Sender<Self>),
885
886    Request(Action),
887    Response(Result<Action, String>),
888    HWMidiEvents(Vec<HwMidiEvent>),
889    HWMidiOutEvents(Vec<HwMidiEvent>),
890    ClearHWMidiOutEvents,
891    HWFinished,
892    OfflineBounceFinished {
893        result: Result<Action, String>,
894    },
895}
896
897#[cfg(test)]
898mod tests {
899    use super::{AudioClipData, MidiClipData, PitchCorrectionPointData};
900    use serde_json::json;
901
902    #[test]
903    fn audio_clip_data_serde_round_trips_nested_groups() {
904        let clip = AudioClipData {
905            name: "group.wav".to_string(),
906            start: 12,
907            length: 96,
908            offset: 3,
909            input_channel: 1,
910            muted: true,
911            peaks_file: Some("peaks/group.json".to_string()),
912            fade_enabled: false,
913            fade_in_samples: 10,
914            fade_out_samples: 20,
915            preview_name: Some("preview.wav".to_string()),
916            source_name: Some("source.wav".to_string()),
917            source_offset: Some(4),
918            source_length: Some(88),
919            pitch_correction_points: vec![PitchCorrectionPointData {
920                start_sample: 7,
921                length_samples: 11,
922                detected_midi_pitch: 60.1,
923                target_midi_pitch: 61.2,
924                clarity: 0.8,
925            }],
926            pitch_correction_frame_likeness: Some(0.5),
927            pitch_correction_inertia_ms: Some(123),
928            pitch_correction_formant_compensation: Some(false),
929            plugin_graph_json: Some(json!({"plugins":[],"connections":[{"kind":"Audio"}]})),
930            grouped_clips: vec![AudioClipData {
931                name: "child.wav".to_string(),
932                start: 0,
933                length: 48,
934                ..AudioClipData::default()
935            }],
936        };
937
938        let value = serde_json::to_value(&clip).expect("serialize");
939        let restored: AudioClipData = serde_json::from_value(value).expect("deserialize");
940
941        assert_eq!(restored.name, clip.name);
942        assert_eq!(restored.preview_name, clip.preview_name);
943        assert_eq!(restored.source_name, clip.source_name);
944        assert_eq!(restored.plugin_graph_json, clip.plugin_graph_json);
945        assert_eq!(restored.grouped_clips.len(), 1);
946        assert_eq!(restored.grouped_clips[0].name, "child.wav");
947        assert_eq!(restored.pitch_correction_points[0].target_midi_pitch, 61.2);
948    }
949
950    #[test]
951    fn midi_clip_data_serde_round_trips_nested_groups() {
952        let clip = MidiClipData {
953            name: "group.mid".to_string(),
954            start: 5,
955            length: 64,
956            offset: 2,
957            input_channel: 3,
958            muted: true,
959            grouped_clips: vec![MidiClipData {
960                name: "child.mid".to_string(),
961                start: 0,
962                length: 32,
963                ..MidiClipData::default()
964            }],
965        };
966
967        let value = serde_json::to_value(&clip).expect("serialize");
968        let restored: MidiClipData = serde_json::from_value(value).expect("deserialize");
969
970        assert_eq!(restored.name, clip.name);
971        assert_eq!(restored.grouped_clips.len(), 1);
972        assert_eq!(restored.grouped_clips[0].name, "child.mid");
973    }
974
975    #[test]
976    fn pitch_correction_point_data_serde_round_trips() {
977        let point = PitchCorrectionPointData {
978            start_sample: 10,
979            length_samples: 20,
980            detected_midi_pitch: 57.5,
981            target_midi_pitch: 58.0,
982            clarity: 0.9,
983        };
984
985        let value = serde_json::to_value(&point).expect("serialize");
986        let restored: PitchCorrectionPointData =
987            serde_json::from_value(value).expect("deserialize");
988
989        assert_eq!(restored.start_sample, 10);
990        assert_eq!(restored.length_samples, 20);
991        assert_eq!(restored.detected_midi_pitch, 57.5);
992        assert_eq!(restored.target_midi_pitch, 58.0);
993        assert_eq!(restored.clarity, 0.9);
994    }
995
996    #[test]
997    fn audio_clip_data_deserializes_with_omitted_optional_fields() {
998        let restored: AudioClipData = serde_json::from_value(json!({
999            "name": "clip.wav",
1000            "start": 1,
1001            "length": 2,
1002            "offset": 3,
1003            "input_channel": 0,
1004            "muted": false,
1005            "fade_enabled": true,
1006            "fade_in_samples": 240,
1007            "fade_out_samples": 240,
1008            "pitch_correction_points": [],
1009            "grouped_clips": []
1010        }))
1011        .expect("deserialize");
1012
1013        assert_eq!(restored.name, "clip.wav");
1014        assert!(restored.peaks_file.is_none());
1015        assert!(restored.preview_name.is_none());
1016        assert!(restored.source_name.is_none());
1017        assert!(restored.source_offset.is_none());
1018        assert!(restored.source_length.is_none());
1019        assert!(restored.pitch_correction_points.is_empty());
1020        assert!(restored.plugin_graph_json.is_none());
1021    }
1022}
maolan_engine/message.rs

maolan_engine/
message.rs
