apply delay only for notes above duration threshold

Author: valsteen

note_off_delay/src/lib.rs

@@ -20,6 +20,7 @@ use util::delayed_message_consumer::{process_scheduled_events, MessageReason};
 use util::messages::format_event;
 use util::midi_message_type::MidiMessageType;
 use util::parameters::ParameterConversion;
+use crate::parameters::PARAMETER_COUNT;
 
 plugin_main!(NoteOffDelayPlugin);
 
@@ -90,7 +91,7 @@ impl Plugin for NoteOffDelayPlugin {
             name: "Note Off Delay".to_string(),
             vendor: "DJ Crontab".to_string(),
             unique_id: 234213173,
-            parameters: 4,
+            parameters: PARAMETER_COUNT as i32,
             category: Category::Effect,
             initial_delay: 0,
             version: 1,
@@ -188,7 +189,7 @@ impl Plugin for NoteOffDelayPlugin {
                             None => {}
                             Some(note_on) => {
                                 let duration = note_off_play_time - note_on.play_time_in_samples;
-                                match self.parameters.get_delay().apply(duration, self.sample_rate) {
+                                match delay.apply(duration, self.sample_rate) {
                                     None => panic!("delay is supposed to be active"),
                                     Some(new_duration) => {
                                         // send two times the note off, the live one will be only used to mark the note on as delayed

note_off_delay/src/parameters.rs

@@ -5,12 +5,12 @@ use vst::util::ParameterTransfer;
 
 use util::parameter_value_conversion::{f32_to_bool, f32_to_byte};
 use util::parameters::{ParameterConversion, get_exponential_scale_value};
-use util::{HostCallbackLock, DelayOffset};
+use util::{HostCallbackLock, Duration};
 use util::delayed_message_consumer::MaxNotesParameter;
 use std::fmt::{Display, Formatter};
 use std::fmt;
 
-const PARAMETER_COUNT: usize = 4;
+pub const PARAMETER_COUNT: usize = 5;
 
 pub struct NoteOffDelayPluginParameters {
     pub host_mutex: Mutex<HostCallbackLock>,
@@ -23,6 +23,7 @@ pub enum Parameter {
     MaxNotes,
     MaxNotesAppliesToDelayedNotesOnly,
     MultiplyLength,
+    Threshold
 }
 
 impl From<i32> for Parameter {
@@ -32,6 +33,7 @@ impl From<i32> for Parameter {
             1 => Parameter::MaxNotes,
             2 => Parameter::MaxNotesAppliesToDelayedNotesOnly,
             3 => Parameter::MultiplyLength,
+            4 => Parameter::Threshold,
             _ => panic!("no such parameter {}", i),
         }
     }
@@ -71,8 +73,9 @@ impl NoteOffDelayPluginParameters {
 
     pub fn get_delay(&self) -> Delay {
         Delay {
-            offset: DelayOffset::from(self.get_parameter(Parameter::DelayOffset.into())),
-            multiplier: DelayMultiplier::from(self.get_parameter(Parameter::MultiplyLength.into()))
+            offset: Duration::from(self.get_parameter(Parameter::DelayOffset.into())),
+            multiplier: DelayMultiplier::from(self.get_parameter(Parameter::MultiplyLength.into())),
+            threshold: Duration::from(self.get_parameter(Parameter::Threshold.into())),
         }
     }
 }
@@ -88,8 +91,9 @@ impl Default for NoteOffDelayPluginParameters {
 
 
 pub struct Delay {
-    pub offset: DelayOffset,
+    pub offset: Duration,
     pub multiplier: DelayMultiplier,
+    pub threshold: Duration
 }
 
 
@@ -100,19 +104,26 @@ pub enum DelayMultiplier {
 
 impl Delay {
     pub fn is_active(&self) -> bool {
-        !matches!((&self.offset, &self.multiplier), (DelayOffset::Off, DelayMultiplier::Off))
+        !matches!((&self.offset, &self.multiplier), (Duration::Off, DelayMultiplier::Off))
     }
 
     pub fn apply(&self, duration_in_samples: usize, sample_rate: f32) -> Option<usize> {
         if self.is_active() {
+            if let Duration::Duration(threshold) = self.threshold {
+                let threshold_in_samples = (threshold * sample_rate) as usize;
+                if duration_in_samples < threshold_in_samples {
+                    return Some(duration_in_samples)
+                }
+            }
+
             let duration_in_samples = match self.multiplier {
                 DelayMultiplier::Off => duration_in_samples as f32,
                 DelayMultiplier::Multiplier(x) => x * duration_in_samples as f32
             };
 
             Some(match self.offset {
-                DelayOffset::Off => duration_in_samples as usize,
-                DelayOffset::Duration(x) => (duration_in_samples + x * sample_rate) as usize
+                Duration::Off => duration_in_samples as usize,
+                Duration::Duration(x) => (duration_in_samples + x * sample_rate) as usize
             })
         } else {
             None
@@ -145,13 +156,14 @@ impl From<f32> for DelayMultiplier {
 
 impl vst::plugin::PluginParameters for NoteOffDelayPluginParameters {
     fn get_parameter_text(&self, index: i32) -> String {
+        let value = self.get_parameter(index);
         match index.into() {
-            Parameter::DelayOffset => {
-                DelayOffset::from(self.get_parameter(Parameter::DelayOffset as i32)).to_string()
+            Parameter::DelayOffset | Parameter::Threshold => {
+                Duration::from(value).to_string()
             }
 
             Parameter::MaxNotes => {
-                if self.get_parameter(Parameter::MaxNotes as i32) == 0.0 {
+                if value == 0.0 {
                     "Off".to_string()
                 } else {
                     format!("{}", self.get_max_notes())
@@ -166,7 +178,7 @@ impl vst::plugin::PluginParameters for NoteOffDelayPluginParameters {
                 }.to_string()
             }
             Parameter::MultiplyLength => {
-                DelayMultiplier::from(self.get_parameter(Parameter::MultiplyLength as i32)).to_string()
+                DelayMultiplier::from(value).to_string()
             }
         }
     }
@@ -176,7 +188,8 @@ impl vst::plugin::PluginParameters for NoteOffDelayPluginParameters {
             Parameter::DelayOffset => "Delay",
             Parameter::MaxNotes => "Max Notes",
             Parameter::MaxNotesAppliesToDelayedNotesOnly => "Apply max notes to delayed notes only",
-            Parameter::MultiplyLength => "Length multiplier"
+            Parameter::MultiplyLength => "Length multiplier",
+            Parameter::Threshold => "Threshold"
         }
             .to_string()
     }
@@ -187,7 +200,7 @@ impl vst::plugin::PluginParameters for NoteOffDelayPluginParameters {
 
     fn set_parameter(&self, index: i32, value: f32) {
         match index.into() {
-            Parameter::DelayOffset | Parameter::MultiplyLength => {
+            Parameter::DelayOffset | Parameter::MultiplyLength | Parameter::Threshold => {
                 let old_value = self.get_parameter(index);
                 if (value - old_value).abs() > 0.0001 || (value == 0.0 && old_value != 0.0) {
                     self.transfer.set_parameter(index as usize, value)

util/src/lib.rs

@@ -51,27 +51,28 @@ pub fn duration_display(seconds: f32) -> String {
     out
 }
 
-impl Display for DelayOffset {
+impl Display for Duration {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
-            DelayOffset::Off => "off".to_string(),
-            DelayOffset::Duration(seconds) => {
+            Duration::Off => "off".to_string(),
+            Duration::Duration(seconds) => {
                 duration_display(*seconds)
             }
         }.fmt(f)
     }
 }
 
-pub enum DelayOffset {
+pub enum Duration {
     Off,
     Duration(f32),
 }
 
-impl From<f32> for DelayOffset {
+
+impl From<f32> for Duration {
     fn from(parameter_value: f32) -> Self {
         match get_exponential_scale_value(parameter_value, 10., 20.) {
-            x if x == 0.0 => DelayOffset::Off,
-            value => DelayOffset::Duration(value)
+            x if x == 0.0 => Duration::Off,
+            value => Duration::Duration(value)
         }
     }
 }