Added panic button to delay. Made short delay times possible (down to 1 sample). Added omnijack ins for time and feedback, but they are not working yet.

Author: Hannes Barfuss

Assets/Resources/Prefabs/Delay.prefab

@@ -18,8 +18,9 @@
 
 public class delayDeviceInterface : deviceInterface
 {
-    public omniJack input, output;
+    public omniJack input, cTimeInput, cFeedbackInput, output;
     public dial timeDial, feedbackDial, wetDial, dryDial;
+    public button panicButton;
     delaySignalGenerator signal;
     private dial[] dials;
 
@@ -33,11 +34,15 @@ public override void Awake()
     void Update()
     {
         if (signal.input != input.signal) signal.input = input.signal;
+        if (signal.cFeedbackInput != cFeedbackInput.signal) signal.cFeedbackInput = cFeedbackInput.signal;
+        if (signal.cTimeInput != cTimeInput.signal) signal.cTimeInput = cTimeInput.signal;
 
-        for(int i = 0; i < dials.Length; i++)
+        for (int i = 0; i < dials.Length; i++)
         {
             signal.SetParam(dials[i].percent, i);
         }
+        if (panicButton.isHit)
+            signal.SetParam(1, (int)delaySignalGenerator.Param.P_CLEAR);
     }
 
     public override InstrumentData GetData()

Assets/Scripts/Delay/delayDeviceInterface.cs

@@ -14,23 +14,29 @@ public enum Param : int
         P_FEEDBACK,
         P_WET,
         P_DRY,
+        P_CLEAR,
         P_N
     };
 
-    public const float MIN_TIME = 0.050f; // * 1000ms
-    public const float MAX_TIME = 5.0f; // * 1000 ms
+    public const float MIN_TIME = 0.001f; // * 1000ms
+    public const float MAX_TIME = 0.05f; // * 1000 ms
     public const float MIN_FEEDBACK = 0;
     public const float MAX_FEEDBACK = 1f;
     public const float MIN_WET = -96; //dB
     public const float MAX_WET = 0; //dB
     public const float MIN_DRY = -96; //dB
     public const float MAX_DRY = 0; //dB
 
-    public signalGenerator input;
+    public signalGenerator input, cTimeInput, cFeedbackInput;
 
     private IntPtr x;
     private float[] p = new float[(int)Param.P_N];
-    private bool processing = false;
+    private bool shouldClear = false;
+
+    private float[] cTimeBuffer = new float[2] { 0, 0 };
+    private float[] cFeedbackBuffer = new float[2] { 0, 0 };
+    private float cTime;
+    private float cFeedback;
 
     public override void Awake()
     {
@@ -59,11 +65,15 @@ public void SetParam(float value, int param)
             case (int)Param.P_DRY:
                 p[param] = Utils.dbToLin( Utils.map(value, 0, 1, MIN_DRY, MAX_DRY, 0.8f) );
                 break;
+            case (int)Param.P_CLEAR:
+                if (value != 0)
+                    shouldClear = true;
+                break;
         }
     }
 
     [DllImport("SoundStageNative")]
-    private static extern void Delay_Process(float[] buffer, int length, int channels, IntPtr x);
+    private static extern void Delay_Process(float[] buffer, int length, int channels, float cTime, float cFeedback, IntPtr x);
 
     [DllImport("SoundStageNative")]
     private static extern IntPtr Delay_New(int maxDelayTimeSamples);
@@ -74,8 +84,23 @@ public void SetParam(float value, int param)
     [DllImport("SoundStageNative")]
     private static extern void Delay_SetParam(float value, int param, IntPtr x);
 
+    [DllImport("SoundStageNative")]
+    private static extern void Delay_Clear(IntPtr x);
+
     public override void processBuffer(float[] buffer, double dspTime, int channels)
     {
+        if (cTimeBuffer.Length != buffer.Length)
+            System.Array.Resize(ref cTimeBuffer, buffer.Length);
+
+        if (cFeedbackBuffer.Length != buffer.Length)
+            System.Array.Resize(ref cFeedbackBuffer, buffer.Length);
+
+        if (shouldClear)
+        {
+            Delay_Clear(x);
+            shouldClear = false;
+        }
+
         Delay_SetParam(p[(int)Param.P_TIME], (int)Param.P_TIME, x);
         Delay_SetParam(p[(int)Param.P_FEEDBACK], (int)Param.P_FEEDBACK, x);
         Delay_SetParam(p[(int)Param.P_WET], (int)Param.P_WET, x);
@@ -86,11 +111,25 @@ public override void processBuffer(float[] buffer, double dspTime, int channels)
             input.processBuffer(buffer, dspTime, channels);
         }
 
+        cTime = cFeedback = 0;
+
+        if (cTimeInput != null)
+        {
+            cTimeInput.processBuffer(cTimeBuffer, dspTime, channels);
+            cTime = cTimeBuffer[0];
+        }
+
+        if (cFeedbackInput != null)
+        {
+            cFeedbackInput.processBuffer(cFeedbackBuffer, dspTime, channels);
+            cFeedback = cFeedbackBuffer[0];
+        }
+
         //We need to process the delay even if there is currently no input,
         //bc there could be unconsumed samples from a previous input left in the delay line.
         //To optimize, we could store the timestamp when the last input connection was removed.
         //Then we only have to process if P_TIME is larger then the elapsed time since the connection was removed.
-        Delay_Process(buffer, buffer.Length, channels, x);
+        Delay_Process(buffer, buffer.Length, channels, cTime, cFeedback, x);
     }
 }
 

Assets/Scripts/Delay/delaySignalGenerator.cs

@@ -19,35 +19,45 @@ enum DelayParams
     P_N
 };
 
-/* TODO: Right now, if x->time < n, the delay will produce strange glitches. */
-void Delay_ProcessPitchShift(float buffer[], int n, int channels, DelayData* x)
+void Delay_ProcessPitchShift(float buffer[], int n, int channels, float cTime, float cFeedback, DelayData* x)
 {
-    assert(x->time > 0);
-    float stride = (float)x->maxTime / (float)x->time;
+    /* Prepare */
+    int time = cTime != 0 ? (x->maxTime - x->time) * cTime : x->time;
+    float feedback = cFeedback != 0 ? (1.0f - x->feedback) * cFeedback : x->feedback;
 
-    if(x->time < n)
-    {
-        /* if the delay time is shorter than the buffer, then we should avoid writing samples we will not use anyway.
-         This is especially important since short delay times resut in more oversampling and thus more CPU load...
-         */
-    }
+    assert(time > 0);
+    
+    float stride = (float)x->maxTime / (float)time;
 
     int nPerChannel = n/channels;
     if(channels > 1)
         _fDeinterleave(buffer, buffer, n, channels);
 
-    RingBuffer_ReadPadded(x->temp, nPerChannel, -(x->maxTime), stride, x->tap);
-    _fCopy(x->temp, x->temp2, nPerChannel);
-    
-    _fScale(x->temp, x->temp, x->feedback, nPerChannel);
-    _fAdd(buffer, x->temp, x->temp, nPerChannel);
-    RingBuffer_WritePadded(x->temp, nPerChannel, stride, x->tap);
+    /* Process delay */
+    int m;
+    int r = nPerChannel;
+    float* bufOffset = buffer;
+    while(r)
+    {
+        m = time < r ? time : r;
+        
+        RingBuffer_ReadPadded(x->temp, m, -(x->maxTime), stride, x->tap);
+        _fCopy(x->temp, x->temp2, m);
+        
+        _fScale(x->temp, x->temp, feedback, m);
+        _fAdd(bufOffset, x->temp, x->temp, m);
+        RingBuffer_WritePadded(x->temp, m, stride, x->tap);
 
-    _fScale(buffer, buffer, x->dry, nPerChannel);
-    _fScale(x->temp2, x->temp2, x->wet, nPerChannel);
+        _fScale(bufOffset, bufOffset, x->dry, m);
+        _fScale(x->temp2, x->temp2, x->wet, m);
+            
+        _fAdd(bufOffset, x->temp2, bufOffset, m);
 
-    _fAdd(buffer, x->temp2, buffer, nPerChannel);
+        bufOffset += m;
+        r -= m;
+    }
 
+    /* Finalize */
     if(channels > 1)
     {
         for(int i = 1; i < channels; i++)
@@ -84,12 +94,17 @@ void Delay_ProcessSimple(float buffer[], int n, int channels, DelayData* x) {
 }
 
 
-SOUNDSTAGE_API void Delay_Process(float buffer[], int n, int channels, DelayData* x)
+SOUNDSTAGE_API void Delay_Process(float buffer[], int n, int channels, float cTime, float cFeedback, DelayData* x)
 {
-    Delay_ProcessPitchShift(buffer, n, channels, x);
+    Delay_ProcessPitchShift(buffer, n, channels, cTime, cFeedback, x);
     //Delay_ProcessSimple(buffer, n, channels, x);
 }
 
+SOUNDSTAGE_API void Delay_Clear(DelayData* x)
+{
+    _fZero(x->tap->buf, x->tap->n);
+}
+
 SOUNDSTAGE_API void Delay_SetParam(float value, int param, struct DelayData *x)
 {
     assert(param < P_N);
@@ -99,11 +114,6 @@ SOUNDSTAGE_API void Delay_SetParam(float value, int param, struct DelayData *x)
     switch (param) {
         case P_TIME:
             assert(value <= x->tap->n);
-            if(intval % 2 != 0)
-            {
-                //This is a quick hack to ensure the ringbuffer will not randomly switch left and right channels when used with interleaved audio data.
-                value--;
-            }
             x->time = intval;
             //printv("Set delay time to %d\n", intval);
             break;

Assets/SoundStageNative/arm64/Release/libSoundStageNative.so

@@ -29,7 +29,9 @@ SOUNDSTAGE_API void Delay_Free(struct DelayData *x);
 ///Sets the parameter to the specified value.
 SOUNDSTAGE_API void Delay_SetParam(float value, int param, struct DelayData *x);
 ///Processes 1 block of interleaved audio data.
-SOUNDSTAGE_API void Delay_Process(float buffer[], int n, int channels, DelayData* x);
+SOUNDSTAGE_API void Delay_Process(float buffer[], int n, int channels, float cTime, float cFeedback, DelayData* x);
+//Clears the delay buffer.
+SOUNDSTAGE_API void Delay_Clear(DelayData* x);
 #ifdef __cplusplus
 }
 #endif

SoundStageNative/Delay.cpp

@@ -48,7 +48,7 @@ SOUNDSTAGE_API int RingBuffer_WritePadded(float *src, int n, float stride, struc
         //Wrap fPtr
         while(fPtr >= x->n) // >= bc max valid index is n-1
             fPtr -= x->n;
-        while(m >= x->n) // > bc can write n samples max
+        while(m > x->n) // > bc can write n samples max
             m -= x->n;
 
         //printv("fPtr == %f, m == %d, x->ptr == %d\n", fPtr, m, x->ptr);

SoundStageNative/Delay.h

@@ -143,15 +143,20 @@ extern "C" {
         /* Surprisingly, this version is a little faster than using vmulq_n_f32.
          But it uses one register more (float32x4_t scale).
          */
-        assert(n % 4 == 0);
-        float32x4_t scale = vdupq_n_f32(factor);
-        float32x4_t temp;
-        for(int i = 0; i < n; i+= 4)
+        if(n % 4 == 0)
         {
-            temp = vld1q_f32(src + i);
-            temp = vmulq_f32(temp, scale);
-            vst1q_f32(src + i, temp);
+            float32x4_t scale = vdupq_n_f32(factor);
+            float32x4_t temp;
+            for(int i = 0; i < n; i+= 4)
+            {
+                temp = vld1q_f32(src + i);
+                temp = vmulq_f32(temp, scale);
+                vst1q_f32(src + i, temp);
+            }
         }
+        else
+            for(int i = 0; i < n; i++)
+                dest[i] = factor * src[i];
 #else
         for(int i = 0; i < n; i++)
         {
@@ -196,16 +201,21 @@ extern "C" {
         /* 1.5x as fast as naive implementation (Onone) */
         /* TODO: naive implementation is twice as fast (O3) */
         /* A bit slower than naive implementation (Ofast). Interestingly, the Neon version gets a speedup from O3 to Ofast, while the naive implementation does not change. */
-        assert(n % 4 == 0);
-        float32x4_t temp1;
-        float32x4_t temp2;
-        for(int i = 0; i < n; i+=4)
+        if(n % 4 == 0)
         {
-            temp1 = vld1q_f32(src1 + i);
-            temp2 = vld1q_f32(src2 + i);
-            temp2 = vaddq_f32(temp1, temp2);
-            vst1q_f32(dest + i, temp2);
+            float32x4_t temp1;
+            float32x4_t temp2;
+            for(int i = 0; i < n; i+=4)
+            {
+                temp1 = vld1q_f32(src1 + i);
+                temp2 = vld1q_f32(src2 + i);
+                temp2 = vaddq_f32(temp1, temp2);
+                vst1q_f32(dest + i, temp2);
+            }
         }
+        else
+            for(int i = 0; i < n; i++)
+                dest[i] = src1[i] + src2[i];
 #else
         for(int i = 0; i < n; i++)
         {