fixed

packages/core/util.mjs

@@ -61,6 +61,11 @@ export const valueToMidi = (value, fallbackValue) => {
   return fallbackValue;
 };
 
+// used to schedule external event like midi and osc out
+export const getEventOffsetMs = (targetTime, currentTime) => {
+  return (targetTime - currentTime) * 1000;
+};
+
 /**
  * @deprecated does not appear to be referenced or invoked anywhere in the codebase
  * @noAutocomplete

packages/desktopbridge/oscbridge.mjs

@@ -1,8 +1,8 @@
-import { parseNumeral, Pattern } from '@strudel/core';
+import { parseNumeral, Pattern, getEventOffsetMs } from '@strudel/core';
 import { Invoke } from './utils.mjs';
 
 Pattern.prototype.osc = function () {
-  return this.onTrigger(async (time, hap, currentTime, cps = 1) => {
+  return this.onTrigger(async (time, hap, currentTime, cps = 1, targetTime) => {
     hap.ensureObjectValue();
     const cycle = hap.wholeOrPart().begin.valueOf();
     const delta = hap.duration.valueOf();
@@ -13,7 +13,7 @@ Pattern.prototype.osc = function () {
 
     const params = [];
 
-    const timestamp = Math.round(Date.now() + (time - currentTime) * 1000);
+    const timestamp = Math.round(Date.now() + getEventOffsetMs(targetTime, currentTime));
 
     Object.keys(controls).forEach((key) => {
       const val = controls[key];

packages/midi/midi.mjs

@@ -5,7 +5,7 @@ This program is free software: you can redistribute it and/or modify it under th
 */
 
 import * as _WebMidi from 'webmidi';
-import { Pattern, isPattern, logger, ref } from '@strudel/core';
+import { Pattern, getEventOffsetMs, isPattern, logger, ref } from '@strudel/core';
 import { noteToMidi } from '@strudel/core';
 import { Note } from 'webmidi';
 // if you use WebMidi from outside of this package, make sure to import that instance:
@@ -120,9 +120,9 @@ Pattern.prototype.midi = function (output) {
     const device = getDevice(output, WebMidi.outputs);
     hap.ensureObjectValue();
     //magic number to get audio engine to line up, can probably be calculated somehow
-    const latency = 0.034;
+    const latencyMs = 34;
     // passing a string with a +num into the webmidi api adds an offset to the current time https://webmidijs.org/api/classes/Output
-    const timeOffsetString = `+${(targetTime - currentTime + latency) * 1000}`;
+    const timeOffsetString = `${getEventOffsetMs(targetTime, currentTime) + latencyMs}`;
 
     // destructure value
     let { note, nrpnn, nrpv, ccn, ccv, midichan = 1, midicmd, gain = 1, velocity = 0.9 } = hap.value;

packages/osc/osc.mjs

@@ -6,7 +6,7 @@ This program is free software: you can redistribute it and/or modify it under th
 
 import OSC from 'osc-js';
 
-import { logger, parseNumeral, Pattern } from '@strudel/core';
+import { logger, parseNumeral, Pattern, getEventOffsetMs } from '@strudel/core';
 
 let connection; // Promise<OSC>
 function connect() {
@@ -44,7 +44,7 @@ function connect() {
  * @returns Pattern
  */
 Pattern.prototype.osc = function () {
-  return this.onTrigger(async (time, hap, currentTime, cps = 1) => {
+  return this.onTrigger(async (time, hap, currentTime, cps = 1, targetTime) => {
     hap.ensureObjectValue();
     const osc = await connect();
     const cycle = hap.wholeOrPart().begin.valueOf();
@@ -56,7 +56,8 @@ Pattern.prototype.osc = function () {
     const keyvals = Object.entries(controls).flat();
     // time should be audio time of onset
     // currentTime should be current time of audio context (slightly before time)
-    const offset = (time - currentTime) * 1000;
+    const offset = getEventOffsetMs(targetTime, currentTime);
+
     // timestamp in milliseconds used to trigger the osc bundle at a precise moment
     const ts = Math.floor(Date.now() + offset);
     const message = new OSC.Message('/dirt/play', ...keyvals);

src-tauri/src/oscbridge.rs

@@ -1,13 +1,13 @@
-use rosc::{ encoder, OscTime };
-use rosc::{ OscMessage, OscPacket, OscType, OscBundle };
+use rosc::{encoder, OscTime};
+use rosc::{OscBundle, OscMessage, OscPacket, OscType};
 
 use std::net::UdpSocket;
 
-use std::time::Duration;
-use std::sync::Arc;
-use tokio::sync::{ mpsc, Mutex };
 use serde::Deserialize;
+use std::sync::Arc;
 use std::thread::sleep;
+use std::time::Duration;
+use tokio::sync::{mpsc, Mutex};
 
 use crate::loggerbridge::Logger;
 pub struct OscMsg {
@@ -28,9 +28,11 @@ pub fn init(
     logger: Logger,
     async_input_receiver: mpsc::Receiver<Vec<OscMsg>>,
     mut async_output_receiver: mpsc::Receiver<Vec<OscMsg>>,
-  async_output_transmitter: mpsc::Sender<Vec<OscMsg>>
+    async_output_transmitter: mpsc::Sender<Vec<OscMsg>>,
 ) {
-  tauri::async_runtime::spawn(async move { async_process_model(async_input_receiver, async_output_transmitter).await });
+    tauri::async_runtime::spawn(async move {
+        async_process_model(async_input_receiver, async_output_transmitter).await
+    });
     let message_queue: Arc<Mutex<Vec<OscMsg>>> = Arc::new(Mutex::new(Vec::new()));
     /* ...........................................................
            Listen For incoming messages and add to queue
@@ -56,7 +58,8 @@ pub fn init(
         let sock = UdpSocket::bind("127.0.0.1:57122").unwrap();
         let to_addr = String::from("127.0.0.1:57120");
         sock.set_nonblocking(true).unwrap();
-    sock.connect(to_addr).expect("could not connect to OSC address");
+        sock.connect(to_addr)
+            .expect("could not connect to OSC address");
 
         /* ...........................................................
                             Process queued messages
@@ -69,8 +72,10 @@ pub fn init(
                 let result = sock.send(&message.msg_buf);
                 if result.is_err() {
                     logger.log(
-            format!("OSC Message failed to send, the server might no longer be available"),
-            "error".to_string()
+                        format!(
+                            "OSC Message failed to send, the server might no longer be available"
+                        ),
+                        "error".to_string(),
                     );
                 }
                 return false;
@@ -83,7 +88,7 @@ pub fn init(
 
 pub async fn async_process_model(
     mut input_reciever: mpsc::Receiver<Vec<OscMsg>>,
-  output_transmitter: mpsc::Sender<Vec<OscMsg>>
+    output_transmitter: mpsc::Sender<Vec<OscMsg>>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     while let Some(input) = input_reciever.recv().await {
         let output = input;
@@ -108,7 +113,7 @@ pub struct MessageFromJS {
 #[tauri::command]
 pub async fn sendosc(
     messagesfromjs: Vec<MessageFromJS>,
-  state: tauri::State<'_, AsyncInputTransmit>
+    state: tauri::State<'_, AsyncInputTransmit>,
 ) -> Result<(), String> {
     let async_proc_input_tx = state.inner.lock().await;
     let mut messages_to_process: Vec<OscMsg> = Vec::new();
@@ -123,10 +128,10 @@ pub async fn sendosc(
             }
         }
 
-    let duration_since_epoch = Duration::from_millis(m.timestamp) + Duration::new(UNIX_OFFSET, 0);
+        let duration_since_epoch =
+            Duration::from_millis(m.timestamp) + Duration::new(UNIX_OFFSET, 0);
 
-    let seconds = u32
-      ::try_from(duration_since_epoch.as_secs())
+        let seconds = u32::try_from(duration_since_epoch.as_secs())
             .map_err(|_| "bit conversion failed for osc message timetag")?;
 
         let nanos = duration_since_epoch.subsec_nanos() as f64;
@@ -153,5 +158,8 @@ pub async fn sendosc(
         messages_to_process.push(message_to_process);
     }
 
-  async_proc_input_tx.send(messages_to_process).await.map_err(|e| e.to_string())
+    async_proc_input_tx
+        .send(messages_to_process)
+        .await
+        .map_err(|e| e.to_string())
 }