feat(nodes/timecode): add ltc decode node

Author: maxjoehnk

Cargo.lock

@@ -241,6 +241,15 @@ impl Timecode {
         let frames = frames.round() as u64;
         Self::build(frames, false, fps as u64)
     }
+    
+    pub fn to_duration(&self, fps: f64) -> Duration {
+        let frames = self.frames as f64 / fps;
+        let seconds = self.seconds as f64;
+        let minutes = self.minutes as f64 * 60f64;
+        let hours = self.hours as f64 * 3600f64;
+        
+        Duration::from_secs_f64(hours + minutes + seconds + frames)
+    }
 
     const fn build(frames: u64, negative: bool, fps: u64) -> Self {
         let seconds = frames / fps;

crates/runtime/clock/src/lib.rs

@@ -160,6 +160,7 @@ node_type_name! {
         TimecodeControl,
         TimecodeOutput,
         TimecodeRecorder,
+        LtcDecoder,
         AudioFile,
         AudioOutput,
         AudioVolume,

crates/runtime/pipeline/node/src/introspection.rs

@@ -54,7 +54,7 @@ pub use mizer_sequencer_nodes::SequencerNode;
 pub use mizer_step_sequencer_nodes::StepSequencerNode;
 pub use mizer_surface_nodes::SurfaceMappingNode;
 pub use mizer_text_nodes::VideoTextNode;
-pub use mizer_timecode_nodes::{TimecodeControlNode, TimecodeOutputNode, TimecodeRecorderNode};
+pub use mizer_timecode_nodes::{TimecodeControlNode, TimecodeOutputNode, TimecodeRecorderNode, LtcDecoderNode};
 pub use mizer_timing_nodes::{CountdownNode, DelayNode, TimeTriggerNode};
 pub use mizer_traktor_kontrol_nodes::{TraktorKontrolX1InputNode, TraktorKontrolX1OutputNode};
 pub use mizer_transport_nodes::{BeatsNode, TransportNode};
@@ -320,6 +320,7 @@ node_impl! {
     TimecodeControl(TimecodeControlNode),
     TimecodeOutput(TimecodeOutputNode),
     TimecodeRecorder(TimecodeRecorderNode),
+    LtcDecoder(LtcDecoderNode),
     AudioFile(AudioFileNode),
     AudioOutput(AudioOutputNode),
     AudioVolume(AudioVolumeNode),

crates/runtime/pipeline/nodes/src/lib.rs

@@ -9,4 +9,7 @@ anyhow = "1"
 tracing = "0.1"
 serde = { version = "1", features = ["derive"] }
 mizer-node = { path = "../../node" }
+mizer-audio-nodes = { path = "../audio" }
 mizer-timecode = { path = "../../../../components/timecode" }
+mizer-clock = { path = "../../../clock" }
+ltc = "0.2"

crates/runtime/pipeline/nodes/timecode/Cargo.toml

@@ -1,7 +1,9 @@
 pub use self::control::TimecodeControlNode;
 pub use self::output::TimecodeOutputNode;
 pub use self::recorder::TimecodeRecorderNode;
+pub use self::ltc_decoder::LtcDecoderNode;
 
 mod control;
 mod output;
 mod recorder;
+mod ltc_decoder;

crates/runtime/pipeline/nodes/timecode/src/lib.rs

@@ -0,0 +1,109 @@
+use ltc::LTCDecoder;
+use serde::{Deserialize, Serialize};
+use mizer_audio_nodes::{AudioContext, Signal};
+use mizer_clock::Timecode;
+use mizer_node::*;
+
+const AUDIO_INPUT: &str = "LTC";
+const TIMECODE_OUTPUT: &str = "Clock";
+
+const FPS_SETTING: &str = "FPS";
+
+const SAMPLE_RATE: u32 = 44_100;
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+pub struct LtcDecoderNode {
+    pub fps: f64,
+}
+
+impl Default for LtcDecoderNode {
+    fn default() -> Self {
+        Self {
+            fps: 30.0,
+        }
+    }
+}
+
+impl ConfigurableNode for LtcDecoderNode {
+    fn settings(&self, _injector: &Injector) -> Vec<NodeSetting> {
+        vec![
+            setting!(FPS_SETTING, self.fps),
+        ]
+    }
+
+    fn update_setting(&mut self, setting: NodeSetting) -> anyhow::Result<()> {
+        update!(float setting, FPS_SETTING, self.fps);
+
+        update_fallback!(setting)
+    }
+}
+
+impl PipelineNode for LtcDecoderNode {
+    fn details(&self) -> NodeDetails {
+        NodeDetails {
+            node_type_name: "LTC Decoder".into(),
+            preview_type: PreviewType::Timecode,
+            category: NodeCategory::Standard,
+        }
+    }
+
+    fn display_name(&self, _injector: &Injector) -> String {
+        format!("LTC Decoder ({} FPS)", self.fps)
+    }
+
+    fn list_ports(&self, _injector: &Injector) -> Vec<(PortId, PortMetadata)> {
+        vec![
+            input_port!(AUDIO_INPUT, PortType::Multi),
+            output_port!(TIMECODE_OUTPUT, PortType::Clock),
+        ]
+    }
+
+    fn node_type(&self) -> NodeType {
+        NodeType::LtcDecoder
+    }
+}
+
+impl ProcessingNode for LtcDecoderNode {
+    type State = LTCDecoder;
+
+    fn process(&self, context: &impl NodeContext, state: &mut Self::State) -> anyhow::Result<()> {
+        let Some(mut signal) = context.input_signal(AUDIO_INPUT) else {
+            return Ok(());
+        };
+
+        let frames = context.transfer_size_per_channel();
+
+        let frames = (0..frames).map(|_| {
+            let [mono, _] = signal.next();
+            
+            mono as f32
+        }).collect::<Vec<_>>();
+        
+
+        let mut timecode_frame = None;
+        if state.write_samples(&frames) {
+            for frame in state {
+                timecode_frame = Some(frame);
+            }
+        }
+
+        if let Some(frame) = timecode_frame {
+            let timecode = Timecode {
+                hours: frame.hour as u64,
+                minutes: frame.minute as u64,
+                seconds: frame.second as u64,
+                frames: frame.frame as u64,
+                negative: false
+            };
+            context.write_timecode_preview(timecode);
+            let timestamp = timecode.to_duration(context.fps());
+            context.write_port(TIMECODE_OUTPUT, timestamp);
+        }
+
+        Ok(())
+    }
+
+    fn create_state(&self) -> Self::State {
+        LTCDecoder::new(SAMPLE_RATE as f32 / self.fps as f32, Default::default())
+    }
+}