new param menu

.gitignore

@@ -13,6 +13,9 @@
 .waf*
 build/
 
+# build
+maiden/maiden
+
 # xcode
 *.xcbkptlist
 *.xcuserstate

crone/src/Utilities.h

@@ -140,11 +140,11 @@ namespace crone {
     // logarithmic interpolator (aka 1-pole LPF)
     class LogRamp {
         float sampleRate;
-        float time;
         float b;
         float x0;
         float y0;
     public:
+        float time;
         explicit LogRamp(float sr=48000, float t=0.05) : sampleRate(sr), b(1.f), x0(0.f), y0(0.f) {
             sampleRate = sr;
             time = t;

lua/core/audio.lua

@@ -2,6 +2,8 @@
 -- @classmod audio
 -- @alias Audio
 
+local cs = require 'controlspec'
+
 local Audio = {}
 
 --- set headphone gain.
@@ -253,4 +255,174 @@ function Audio.file_info(path)
 end
 
 
+function Audio.add_params()
+  local cs_MAIN_LEVEL = cs.new(-math.huge,0,'db',0,0,"dB")
+  params:add_group("LEVELS",9)
+  params:add_control("output_level", "output", cs_MAIN_LEVEL)
+  params:set_action("output_level",
+    function(x) audio.level_dac(util.dbamp(x)) end)
+  params:add_control("input_level", "input", cs_MAIN_LEVEL)
+  params:set_action("input_level",
+    function(x) audio.level_adc(util.dbamp(x)) end)
+  local cs_MUTE_LEVEL = cs.new(-math.huge,0,'db',0,-math.huge,"dB")
+  params:add_control("monitor_level", "monitor", cs_MUTE_LEVEL)
+  params:set_action("monitor_level",
+    function(x) audio.level_monitor(util.dbamp(x)) end)
+  params:add_control("engine_level", "engine", cs_MAIN_LEVEL)
+  params:set_action("engine_level",
+    function(x) audio.level_eng(util.dbamp(x)) end)
+  params:add_control("softcut_level", "softcut", cs_MAIN_LEVEL)
+  params:set_action("softcut_level",
+    function(x) audio.level_cut(util.dbamp(x)) end)
+  params:add_control("tape_level", "tape", cs_MUTE_LEVEL)
+  params:set_action("tape_level",
+    function(x) audio.level_tape(util.dbamp(x)) end)
+  params:add_separator()
+  params:add_option("monitor_mode", "monitor mode", {"STEREO", "MONO"})
+  params:set_action("monitor_mode",
+    function(x)
+      if x == 1 then audio.monitor_stereo()
+      else audio.monitor_mono() end
+    end)
+  params:add_number("headphone_gain", "headphone gain", 0, 63, 40)
+  params:set_action("headphone_gain",
+    function(x) audio.headphone_gain(x) end)
+
+  params:add_group("REVERB",11)
+  params:add_option("reverb", "reverb", {"OFF", "ON"}, 2)
+  params:set_action("reverb",
+  function(x)
+    if x == 1 then audio.rev_off() else audio.rev_on() end
+  end)
+  local cs_DB_LEVEL = cs.new(-math.huge,18,'db',0,0,"dB")
+  local cs_DB_LEVEL_MUTE = cs.new(-math.huge,18,'db',0,-math.huge,"dB")
+  local cs_DB_LEVEL_9DB = cs.new(-math.huge,18,'db',0,-9,"dB")
+
+  params:add_control("rev_eng_input", "input engine", cs_DB_LEVEL_9DB)
+  params:set_action("rev_eng_input",
+  function(x) audio.level_eng_rev(util.dbamp(x)) end)
+
+  params:add_control("rev_cut_input", "input softcut", cs_DB_LEVEL_9DB)
+  params:set_action("rev_cut_input",
+  function(x) audio.level_cut_rev(util.dbamp(x)) end)
+
+  params:add_control("rev_monitor_input", "input monitor", cs_DB_LEVEL_MUTE)
+  params:set_action("rev_monitor_input",
+  function(x) audio.level_monitor_rev(util.dbamp(x)) end)
+
+  params:add_control("rev_tape_input", "input tape", cs_DB_LEVEL_MUTE)
+  params:set_action("rev_tape_input",
+  function(x) audio.level_tape_rev(util.dbamp(x)) end)
+
+  params:add_control("rev_return_level", "return level", cs_DB_LEVEL)
+  params:set_action("rev_return_level",
+  function(x) audio.level_rev_dac(util.dbamp(x)) end)
+
+
+  local cs_IN_DELAY = cs.new(20,100,'lin',0,60,'ms')
+  params:add_control("rev_pre_delay", "pre delay", cs_IN_DELAY)
+  params:set_action("rev_pre_delay",
+  function(x) audio.rev_param("pre_del",x) end)
+
+  local cs_LF_FC = cs.new(50,1000,'exp',0, 200,'hz')
+  params:add_control("rev_lf_fc", "lf fc", cs_LF_FC)
+  params:set_action("rev_lf_fc",
+  function(x) audio.rev_param("lf_fc",x) end)
+
+  local cs_RT60 = cs.new(0.1,16,'lin',0,6,'s')
+  params:add_control("rev_low_time", "low time", cs_RT60)
+  params:set_action("rev_low_time",
+  function(x) audio.rev_param("low_rt60",x) end)
+  params:add_control("rev_mid_time", "mid time", cs_RT60)
+  params:set_action("rev_mid_time",
+  function(x) audio.rev_param("mid_rt60",x) end)
+
+  local cs_HF_DAMP = cs.new(1500,20000,'exp',0,6000,'hz')
+  params:add_control("rev_hf_damping", "hf damping", cs_HF_DAMP)
+  params:set_action("rev_hf_damping",
+  function(x) audio.rev_param("hf_damp",x) end)
+  --[[
+  local cs_EQ_FREQ1 = cs.new(40,2500,'exp',0,315,'hz')
+  params:add_control("rev_eq1_freq","rev eq1 freq", cs_EQ_FREQ1)
+  params:set_action("rev_eq1_freq",
+  function(x) audio.aux_param("eq1_freq",x) end)
+  local cs_EQ_LVL = cs.new(-15,15,'lin',0,0,"dB")
+  params:add_control("rev_eq1_level","rev eq1 level", cs_EQ_LVL)
+  params:set_action("rev_eq1_level",
+  function(x) audio.aux_param("eq1_level",x) end)
+
+  local cs_EQ_FREQ2 = cs.new(160,10000,'exp',0,1500,'hz')
+  params:add_control("rev_eq2_freq","rev eq2 freq", cs_EQ_FREQ2)
+  params:set_action("rev_eq2_freq",
+  function(x) audio.aux_param("eq2_freq",x) end)
+  params:add_control("rev_eq2_level","rev eq2 level", cs_EQ_LVL)
+  params:set_action("rev_eq2_level",
+  function(x) audio.aux_param("eq2_level",x) end)
+
+  params:add_control("rev_level","rev level", cs_DB_LEVEL)
+  params:set_action("rev_level",
+  function(x) audio.aux_param("level",x) end)
+  --]]
+
+  params:add_group("COMPRESSOR",8)
+  params:add_option("compressor", "compressor", {"OFF", "ON"})
+  params:set_action("compressor",
+  function(x)
+    if x == 1 then
+      audio.comp_off()
+    else
+      audio.comp_on()
+    end
+  end)
+  local cs_params = cs.new(0,1,'lin',0,1,'')
+  params:add_control("comp_mix", "mix", cs_MIX)
+  params:set_action("comp_mix",
+  function(x) audio.comp_mix(x) end)
+
+  local cs_RATIO = cs.new(1,20,'lin',0,4,'')
+  params:add_control("comp_ratio", "ratio", cs_RATIO)
+  params:set_action("comp_ratio",
+  function(x) audio.comp_param("ratio",x) end)
+
+  local cs_THRESH = cs.new(-100,10,'db',0,-18,'dB')
+  params:add_control("comp_threshold", "threshold", cs_THRESH)
+  params:set_action("comp_threshold",
+  function(x) audio.comp_param("threshold",x) end)
+
+  local cs_ATTACK = cs.new(1,1000,'exp',0,5,'ms')
+  params:add_control("comp_attack", "attack", cs_ATTACK)
+  params:set_action("comp_attack",
+  function(x) audio.comp_param("attack", x*0.001) end)
+  local cs_RELEASE = cs.new(1,1000,'exp',0,50,'ms')
+  params:add_control("comp_release", "release", cs_RELEASE)
+  params:set_action("comp_release",
+  function(x) audio.comp_param("release",x * 0.001) end)
+
+  local cs_PREGAIN = cs.new(-20,60,'db',0,0,'dB')
+  params:add_control("comp_pre_gain", "pre gain", cs_PREGAIN)
+  params:set_action("comp_pre_gain",
+  function(x) audio.comp_param("gain_pre",x) end)
+
+  local cs_POSTGAIN = cs.new(-20,60,'db',0,9,'dB')
+  params:add_control("comp_post_gain", "post gain", cs_POSTGAIN)
+  params:set_action("comp_post_gain",
+  function(x) audio.comp_param("gain_post",x) end)
+
+
+  params:add_group("SOFTCUT",3)
+
+  params:add_control("cut_input_adc", "input adc", cs_MAIN_LEVEL)
+  params:set_action("cut_input_adc",
+    function(x) audio.level_adc_cut(util.dbamp(x)) end)
+
+  params:add_control("cut_input_eng", "input engine", cs_MAIN_LEVEL)
+  params:set_action("cut_input_eng",
+    function(x) audio.level_eng_cut(util.dbamp(x)) end)
+
+  params:add_control("cut_input_tape", "input tape", cs_MAIN_LEVEL)
+  params:set_action("cut_input_tape",
+    function(x) audio.level_tape_cut(util.dbamp(x)) end)
+
+end
+
 return Audio

lua/core/menu.lua

@@ -91,8 +91,7 @@ norns.init_done = function(status)
     _menu.locked = false
     _menu.set_mode(false)
   end
-  m["PARAMS"].init_map()
-  m["PARAMS"].read_pmap()
+  m["PARAMS"].reset()
 end
 
 
@@ -214,7 +213,6 @@ m["PARAMS"] = require 'core/menu/params'
 m["SYSTEM"] = require 'core/menu/system'
 m["DEVICES"] = require 'core/menu/devices'
 m["WIFI"] = require 'core/menu/wifi'
-m["AUDIO"] = require 'core/menu/audio'
 m["RESET"] = require 'core/menu/reset'
 m["UPDATE"] = require 'core/menu/update'
 m["SLEEP"] = require 'core/menu/sleep'

lua/core/menu/mix.lua

@@ -11,13 +11,13 @@ m.key = function(n,z)
 end
 
 m.enc = function(n,d)
-  local ch1 = {"output", "monitor", "softcut"}
-  local ch2 = {"input", "engine", "tape"}
+  local ch1 = {"output_level", "monitor_level", "softcut_level"}
+  local ch2 = {"input_level", "engine_level", "tape_level"}
 
   if n==2 then
-    mix:delta(ch1[m.sel],d)
+    params:delta(ch1[m.sel],d)
   elseif n==3 then
-    mix:delta(ch2[m.sel],d)
+    params:delta(ch2[m.sel],d)
   end
 end
 
@@ -31,7 +31,7 @@ m.redraw = function()
 
   local x = -40
   screen.level(2)
-  n = mix:get_raw("output")*48
+  n = params:get_raw("output_level")*48
   screen.rect(x+42.5,55.5,2,-n)
   screen.stroke()
 
@@ -45,7 +45,7 @@ m.redraw = function()
   screen.stroke()
 
   screen.level(2)
-  n = mix:get_raw("input")*48
+  n = params:get_raw("input_level")*48
   screen.rect(x+64.5,55.5,2,-n)
   screen.stroke()
 
@@ -58,22 +58,22 @@ m.redraw = function()
   screen.stroke()
 
   screen.level(2)
-  n = mix:get_raw("monitor")*48
+  n = params:get_raw("monitor_level")*48
   screen.rect(x+86.5,55.5,2,-n)
   screen.stroke()
 
   screen.level(2)
-  n = mix:get_raw("engine")*48
+  n = params:get_raw("engine_level")*48
   screen.rect(x+108.5,55.5,2,-n)
   screen.stroke()
 
   screen.level(2)
-  n = mix:get_raw("softcut")*48
+  n = params:get_raw("softcut_level")*48
   screen.rect(x+130.5,55.5,2,-n)
   screen.stroke()
 
   screen.level(2)
-  n = mix:get_raw("tape")*48
+  n = params:get_raw("tape_level")*48
   screen.rect(x+152.5,55.5,2,-n)
   screen.stroke()