Fx3 beta1

.gitignore

@@ -45,3 +45,8 @@ sdcard
 # Editor related files
 *.swp
 *.swo
+
+.vscode/
+src/test/bin/
+src/test/objects/
+src/test/results/

src/CFileDevice.hpp

@@ -0,0 +1,78 @@
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+//
+// CFileDevice.h
+//
+// Device implementation that writes into a file.
+// This device is a singleton dedicated to allow the Circle CLogger class to output log event into the file instead of the internal buffer.
+// Author: Vincent Gauché
+//
+
+#pragma once 
+
+#include "extra_features.h"
+
+#include <circle/device.h>
+#include <fatfs/ff.h>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <cassert>
+
+class CFileDevice : public CDevice
+{
+    DISALLOW_COPY_AND_ASSIGN(CFileDevice);
+
+private:
+    CFileDevice() :
+        m_file(new FIL())
+    {
+        FRESULT res = f_open(this->m_file, "SD:/debuglog.txt", FA_WRITE | FA_CREATE_ALWAYS);
+        assert(res == FR_OK);
+    }
+
+public:
+    static void UseMeForLogger()
+    {
+        CLogger::Get()->SetNewTarget(&CFileDevice::GetInstance());
+    }
+
+    static CFileDevice& GetInstance()
+    {
+        static CFileDevice Instance;
+
+        return Instance;
+    }
+
+    ~CFileDevice()
+    {
+        f_sync(this->m_file);
+        f_close(this->m_file);    
+    }
+
+    virtual int Write(const void* pBuffer, size_t nCount) override
+    {
+        UINT nb = 0;
+        if(nCount > 0)
+        {
+            f_write(this->m_file, pBuffer, nCount, &nb);
+            f_sync(this->m_file);
+        }
+
+        return (int)nb;
+    }
+
+private:
+    FIL* m_file;
+};

src/Makefile

@@ -6,10 +6,38 @@ CIRCLE_STDLIB_DIR = ../circle-stdlib
 SYNTH_DEXED_DIR = ../Synth_Dexed/src
 CMSIS_DIR = ../CMSIS_5/CMSIS
 
-OBJS = main.o kernel.o minidexed.o config.o userinterface.o uimenu.o \
-       mididevice.o midikeyboard.o serialmididevice.o pckeyboard.o \
-       sysexfileloader.o performanceconfig.o perftimer.o \
-       effect_compressor.o effect_platervbstereo.o uibuttons.o midipin.o
+OBJS := main.o
+OBJS += kernel.o
+OBJS += minidexed.o
+OBJS += config.o
+OBJS += userinterface.o
+OBJS += uimenu.o
+OBJS += mididevice.o
+OBJS += midikeyboard.o
+OBJS += serialmididevice.o
+OBJS += pckeyboard.o
+OBJS += sysexfileloader.o
+OBJS += performanceconfig.o
+OBJS += perftimer.o
+OBJS += effect_compressor.o
+OBJS += effect_platervbstereo.o
+OBJS += fx.o
+OBJS += fx_components.o
+OBJS += fx_svf.o
+OBJS += fx_tube.o
+OBJS += fx_chorus.o
+OBJS += fx_flanger.o
+OBJS += fx_orbitone.o
+OBJS += fx_phaser.o
+OBJS += fx_delay.o
+OBJS += fx_shimmer_helper.o
+OBJS += fx_diffuser.o
+OBJS += fx_pitch_shifter.o
+OBJS += fx_reverberator.o
+OBJS += fx_shimmer_reverb.o
+OBJS += fx_dry.o
+OBJS += uibuttons.o
+OBJS += midipin.o
 
 OPTIMIZE = -O3
 

src/debug.hpp

@@ -0,0 +1,117 @@
+#pragma once
+
+#if defined(DEBUG)
+
+#include <cmath>
+#include <string>
+#include <iostream>
+#include <sstream>
+
+typedef size_t (*ValueInpector)(const std::string& tag, const float32_t valueToTest, const float32_t _min, float32_t _max, bool outDebugInfo);
+
+inline size_t nanValueInspector(const std::string& tag, const float32_t valueToTest, const float32_t _min, float32_t _max, bool outDebugInfo)
+{
+    if(std::isnan(valueToTest))
+    {
+        if(outDebugInfo)
+        {
+            std::cerr << tag << ": nan" << std::endl;
+        }
+        return 1u;
+    }
+
+    return 0u;
+}
+
+inline size_t normalizedValueInspector(const std::string& tag, const float32_t valueToTest, const float32_t _min, float32_t _max, bool outDebugInfo)
+{
+    if(valueToTest > _max || valueToTest < _min)
+    {
+        if(outDebugInfo)
+        {
+            std::cerr << tag << ": out of bounds - value: " << valueToTest << " - boundaries: [" << _min << ", " << _max << "]" << std::endl;
+        }
+        return 1u;
+    }
+
+    return 0u;
+}
+
+inline size_t fullInspector(const std::string& tag, const float32_t valueToTest, const float32_t _min = -1.0f, float32_t _max = 1.0f, bool outDebugInfo = true)
+{
+    if(std::isnan(valueToTest))
+    {
+        if(outDebugInfo)
+        {
+            std::cerr << tag << ": nan" << std::endl;
+        }
+        return 1u;
+    }
+    else if(valueToTest > _max || valueToTest < _min)
+    {
+        if(outDebugInfo)
+        {
+            std::cerr << tag << ": out of bounds - value: " << valueToTest << " - boundaries: [" << _min << ", " << _max << "]" << std::endl;
+        }
+        return 1u;
+    }
+
+    return 0u;
+}
+
+#define SS_RESET(ss, prec, align)               ss.str(""); ss.precision(prec); ss << align; ss << std::fixed
+#define SS_SPACE(ss, spc, nb, align, sep)       ss.fill(spc); ss.width(nb); ss << "" << sep
+#define SS__TEXT(ss, spc, nb, align, sep, txt)  ss << align; ss.fill(spc); ss.width(nb); ss << txt << sep
+
+class ValueInpectorDebugger
+{
+public:
+    ValueInpectorDebugger() {}
+    virtual ~ValueInpectorDebugger() {}
+
+    virtual void dump(std::ostream& out, bool deepInspection = true, const std::string& tag = "") const = 0;
+    virtual size_t inspect(ValueInpector inspector, bool deepInspection = true, const std::string& tag = "") const = 0;
+};
+
+#define INSPECTABLE(clazz) clazz : public ValueInpectorDebugger
+#define IMPLEMENT_DUMP(code) \
+public:\
+    __attribute__((noinline)) virtual void dump(std::ostream& out, bool deepInspection = true, const std::string& tag = "") const override\
+    {\
+        code\
+    }
+
+#define DUMP(clazz, out) clazz->dump(out, true, "")
+#define DUMP2(clazz, out, tag) clazz->dump(out, true, tag)
+#define FAST_DUMP(clazz, out, tag) clazz->dump(out, false, "")
+#define FAST_DUMP2(clazz, out, tag) clazz->dump(out, false, tag)
+
+#define IMPLEMENT_INSPECT(code) \
+public:\
+    __attribute__((noinline)) virtual size_t inspect(ValueInpector inspector, bool deepInspection = true, const std::string& tag = "") const override\
+    {\
+        code\
+    }
+
+#define INSPECT(obj, inspector) obj->inspect(inspector, true)
+#define INSPECT2(obj, inspector, deepInspection) obj->inspect(inspector, deepInspection)
+#define FULL_INSPECT(obj, deepInspection) obj->inspect(fullInspector, deepInspection)
+#define FULL_INSPECT2(obj, deepInspection, tag) obj->inspect(fullInspector, deepInspection, tag)
+
+#else
+
+#define INSPECTABLE(clazz) clazz
+#define IMPLEMENT_DUMP(code)
+#define IMPLEMENT_INSPECT(code)
+
+#define DUMP(clazz, out)
+#define DUMP2(clazz, out, tag)
+#define FAST_DUMP(clazz, out, tag)
+#define FAST_DUMP2(clazz, out, tag)
+
+#define INSPECT(obj, inspector)
+#define INSPECT2(obj, inspector, deepInspection)
+#define FULL_INSPECT(obj, deepInspection)
+#define FULL_INSPECT2(obj, deepInspection, tag)
+
+#endif

src/effect_mixer.hpp

@@ -33,15 +33,16 @@ template <int NN> class AudioMixer
 		delete [] sumbufL;
 	}
 
-        void doAddMix(uint8_t channel, float32_t* in)
+    void doAddMix(uint8_t channel, float32_t* in)
 	{
-		float32_t tmp[buffer_length];
-
 		assert(in);
 
-		if(multiplier[channel]!=UNITY_GAIN)
+		float32_t tmp[buffer_length];
+		bool isScaled = (multiplier[channel]!=UNITY_GAIN);
+
+		if(isScaled)
 			arm_scale_f32(in,multiplier[channel],tmp,buffer_length);
-		arm_add_f32(sumbufL, tmp, sumbufL, buffer_length);
+		arm_add_f32(sumbufL, (isScaled ? tmp : in), sumbufL, buffer_length);
 	}
 
 	void gain(uint8_t channel, float32_t gain)
@@ -119,37 +120,36 @@ template <int NN> class AudioStereoMixer : public AudioMixer<NN>
 
 	void doAddMix(uint8_t channel, float32_t* in)
 	{
-		float32_t tmp[buffer_length];
-
 		assert(in);
 
+		float32_t tmp[buffer_length];
+
 		// left
-		arm_scale_f32(in, panorama[channel][0], tmp, buffer_length);
-		if(multiplier[channel]!=UNITY_GAIN)
-			arm_scale_f32(tmp,multiplier[channel],tmp,buffer_length);
+		arm_scale_f32(in, panorama[channel][0] * multiplier[channel], tmp, buffer_length);
 		arm_add_f32(sumbufL, tmp, sumbufL, buffer_length);
+
 		// right
-		arm_scale_f32(in, panorama[channel][1], tmp, buffer_length);
-		if(multiplier[channel]!=UNITY_GAIN)
-			arm_scale_f32(tmp,multiplier[channel],tmp,buffer_length);
+		arm_scale_f32(in, panorama[channel][1] * multiplier[channel], tmp, buffer_length);
 		arm_add_f32(sumbufR, tmp, sumbufR, buffer_length);
 	}
 
 	void doAddMix(uint8_t channel, float32_t* inL, float32_t* inR)
 	{
-		float32_t tmp[buffer_length];
-
 		assert(inL);
 		assert(inR);
 
+		float32_t tmp[buffer_length];
+		bool isScaled = (multiplier[channel]!=UNITY_GAIN);
+
 		// left
-		if(multiplier[channel]!=UNITY_GAIN)
+		if(isScaled)
 			arm_scale_f32(inL,multiplier[channel],tmp,buffer_length);
-		arm_add_f32(sumbufL, tmp, sumbufL, buffer_length);
+		arm_add_f32(sumbufL, (isScaled ? tmp : inL), sumbufL, buffer_length);
+
 		// right
-		if(multiplier[channel]!=UNITY_GAIN)
+		if(isScaled)
 			arm_scale_f32(inR,multiplier[channel],tmp,buffer_length);
-		arm_add_f32(sumbufR, tmp, sumbufR, buffer_length);
+		arm_add_f32(sumbufR, (isScaled ? tmp : inR), sumbufR, buffer_length);
 	}
 
 	void getMix(float32_t* bufferL, float32_t* bufferR)