Source: addons/mixer.js

  1. import register from "../util/register.js";
  3. import m_ctl_fact from "../extern/controls.js";
  4. import m_print_fact from "../intern/print.js";
  5. import m_scenes_fact from "../extern/scenes.js";
  6. import m_screen_fact from "../extern/screen.js";
  7. import m_sfx_fact from "../extern/sfx.js";
  8. import m_util_fact from "../extern/util.js";
  10. /**
  11.  * Audio mixer add-on.
  12.  * Implements volume faders, positional params, parametric equalizers per
  13.  * channel and volume fader and compressor to the master section.
  14.  * @module mixer
  15.  */
  16. function Mixer(ns, exports) {
  18. var m_ctl    = m_ctl_fact(ns);
  19. var m_print = m_print_fact(ns);
  20. var m_scenes = m_scenes_fact(ns);
  21. var m_screen = m_screen_fact(ns);
  22. var m_sfx    = m_sfx_fact(ns);
  23. var m_util   = m_util_fact(ns);
  25. var TIMER_SLOW_PERIOD = 0.15;
  26. var TIMER_FAST_PERIOD = 0.05;
  28. var MIXER_CONTROLS_MANIFOLD = ["SWITCH_STRIP", "SWITCH_STRIP_HOLD",
  29.         "SWITCH_PARAM", "INC_DEC", "INC_DEC_HOLD", "MUTE_SOLO"];
  31. var _mixer_strips = [];
  32. var _active_strip = 0;
  34. var _filter_freq_arr = null;
  35. var _filter_mag_arr = null;
  36. var _filter_phase_arr = null;
  38. /**
  39.  * Enable mixer controls.
  40.  */
  41. exports.enable_mixer_controls = function() {
  42.     init();
  44.     // switch mixer strip
  45.     var key_num_left = m_ctl.create_keyboard_sensor(m_ctl.KEY_NUM4);
  46.     var key_num_right = m_ctl.create_keyboard_sensor(m_ctl.KEY_NUM6);
  48.     // switch mixer param
  49.     var key_num_up = m_ctl.create_keyboard_sensor(m_ctl.KEY_NUM8);
  50.     var key_num_down = m_ctl.create_keyboard_sensor(m_ctl.KEY_NUM2);
  52.     // change mixer param value
  53.     var key_num_add = m_ctl.create_keyboard_sensor(m_ctl.KEY_ADD);
  54.     var key_num_sub = m_ctl.create_keyboard_sensor(m_ctl.KEY_SUB);
  56.     // mute-solo
  57.     var key_num_home = m_ctl.create_keyboard_sensor(m_ctl.KEY_NUM7);
  58.     var key_num_pgup = m_ctl.create_keyboard_sensor(m_ctl.KEY_NUM9);
  60.     var timer_slow = m_ctl.create_timer_sensor(TIMER_SLOW_PERIOD, true);
  61.     var timer_fast = m_ctl.create_timer_sensor(TIMER_FAST_PERIOD, true);
  63.     var switch_strip_keys = [key_num_left, key_num_right, timer_slow];
  65.     var switch_strip_logic = function(s) {
  66.         return (s[0] || s[1]);
  67.     }
  68.     var switch_strip_logic_hold = function(s) {
  69.         return ((s[0] || s[1]) && s[2]);
  70.     }
  72.     var switch_spk_cb = function(obj, id, pulse) {
  73.         if (pulse == 1) {
  74.             var dir = Boolean(m_ctl.get_sensor_value(obj, id, 0)) ? -1 : 1;
  75.             switch_strip(dir);
  76.             if (id == "SWITCH_STRIP")
  77.                 m_ctl.reset_timer_sensor(obj, id, 2, TIMER_SLOW_PERIOD + 0.3);
  78.             else
  79.                 m_ctl.reset_timer_sensor(obj, id, 2, TIMER_SLOW_PERIOD);
  80.         } else {
  81.             // hold on some time
  82.             m_ctl.reset_timer_sensor(obj, id, 2, 10);
  83.         }
  84.     }
  85.     m_ctl.create_sensor_manifold(null, "SWITCH_STRIP", m_ctl.CT_TRIGGER, 
  86.             switch_strip_keys, switch_strip_logic, switch_spk_cb);
  87.     m_ctl.create_sensor_manifold(null, "SWITCH_STRIP_HOLD", m_ctl.CT_SHOT, 
  88.             switch_strip_keys, switch_strip_logic_hold, switch_spk_cb);
  90.     var switch_param_keys = [key_num_up, key_num_down];
  91.     var switch_param_logic = function(s) {
  92.         return (s[0] || s[1]);
  93.     }
  94.     var switch_param_cb = function(obj, id, pulse) {
  95.         var dir = Boolean(m_ctl.get_sensor_value(obj, id, 0)) ? -1 : 1;
  96.         switch_param(dir);
  97.     }
  98.     m_ctl.create_sensor_manifold(null, "SWITCH_PARAM", m_ctl.CT_SHOT, 
  99.             switch_param_keys, switch_param_logic, switch_param_cb);
  101.     var inc_dec_keys = [key_num_sub, key_num_add, timer_fast];
  103.     var inc_dec_cb = function(obj, id, pulse) {
  105.         if (pulse == 1) {
  106.             var dir = Boolean(m_ctl.get_sensor_value(obj, id, 0)) ? -1 : 1;
  107.             param_inc_dec(dir);
  109.             if (id == "INC_DEC")
  110.                 m_ctl.reset_timer_sensor(obj, id, 2, TIMER_FAST_PERIOD + 0.3);
  111.             else
  112.                 m_ctl.reset_timer_sensor(obj, id, 2, TIMER_FAST_PERIOD);
  113.         } else {
  114.             // hold on some time
  115.             m_ctl.reset_timer_sensor(obj, id, 2, 10);
  116.         }
  117.     }
  118.     var inc_dec_logic = function(s) {
  119.         return (s[0] || s[1]);
  120.     }
  121.     var inc_dec_logic_hold = function(s) {
  122.         return ((s[0] || s[1]) && s[2]);
  123.     }
  124.     m_ctl.create_sensor_manifold(null, "INC_DEC", m_ctl.CT_TRIGGER, 
  125.             inc_dec_keys, inc_dec_logic, inc_dec_cb);
  126.     m_ctl.create_sensor_manifold(null, "INC_DEC_HOLD", m_ctl.CT_SHOT, 
  127.             inc_dec_keys, inc_dec_logic_hold, inc_dec_cb);
  129.     var mute_solo_keys = [key_num_home, key_num_pgup];  
  131.     var mute_solo_cb = function(obj, id, pulse) {
  132.         var mute_solo = Boolean(m_ctl.get_sensor_value(obj, id, 0));
  133.         if (mute_solo)
  134.             switch_mute();
  135.         else
  136.             switch_solo();
  137.     }
  138.     var mute_solo_logic = function(s) {
  139.         return (s[0] || s[1]);
  140.     }
  141.     m_ctl.create_sensor_manifold(null, "MUTE_SOLO", m_ctl.CT_SHOT,
  142.             mute_solo_keys, mute_solo_logic, mute_solo_cb);
  144.     var elapsed = m_ctl.create_elapsed_sensor();
  146.     m_ctl.create_sensor_manifold(null, "MIXER_DRAW", m_ctl.CT_CONTINUOUS,
  147.         [elapsed], null, function() {draw()});
  149.     var timer = m_ctl.create_timer_sensor(1, true);
  150.     m_ctl.create_sensor_manifold(null, "MIXER_UPDATE", m_ctl.CT_TRIGGER,
  151.             [timer], null, function() {
  152.         var strip_range = active_strip_range();
  153.         for (var i = strip_range[0]; i <= strip_range[1]; i++)
  154.             update_strip_params(_mixer_strips[i]);
  155.     });
  156. }
  158. /**
  159.  * Disable mixer controls.
  160.  */
  161. exports.disable_mixer_controls = function() {
  162.     for (var i = 0; MIXER_CONTROLS_MANIFOLD.length; i++)
  163.         m_ctl.remove_sensor_manifold(null, MIXER_CONTROLS_MANIFOLD[i]);
  164. }
  166. /**
  167.  * Initialize mixer
  168.  */
  169. function init() {
  170.     _mixer_strips.length = 0;
  171.     _active_strip = 0;
  173.     _filter_freq_arr = gen_freq_arr(100);
  174.     _filter_mag_arr = new Float32Array(_filter_freq_arr.length);
  175.     _filter_phase_arr = new Float32Array(_filter_freq_arr.length);
  177.     var speakers = m_sfx.get_speaker_objects();
  178.     if (!speakers.length)
  179.         return;
  181.     _mixer_strips.push(create_master_strip());
  183.     for (var i = 0; i < speakers.length; i++) {
  184.         var spk = speakers[i];
  185.         _mixer_strips.push(create_speaker_strip(spk));
  186.     }
  188.     // special strips first, then by name
  189.     _mixer_strips.sort(function(a,b) {
  190.         if (a.id == "MASTER")
  191.             return -1;
  192.         else if (b.id == "MASTER")
  193.             return 1;
  194.         else if (a.id == "COMPRESSOR")
  195.             return -1;
  196.         else if (b.id == "COMPRESSOR")
  197.             return 1;
  198.         else if (a.id.toUpperCase() < b.id.toUpperCase())
  199.             return -1;
  200.         else if (a.id.toUpperCase() > b.id.toUpperCase())
  201.             return 1;
  202.         else
  203.             return 0;
  204.     });
  205. }
  207. function gen_freq_arr(steps) {
  208.     var FMIN = 20;
  209.     var FMAX = 20000;
  211.     var freq_arr = new Float32Array(steps);
  213.     var freq_base = FMAX/FMIN;
  214.     var freq_pow = 0;
  216.     for (var i = 0; i < steps; i++) {
  217.         freq_arr[i] = FMIN * Math.pow(freq_base, freq_pow);
  218.         freq_pow += 1 / (steps - 1);
  219.     }
  221.     return freq_arr;
  222. }
  224. function create_master_strip() {
  225.     var strip = init_strip("MASTER");
  227.     var cparams = m_sfx.get_compressor_params();
  228.     if (cparams) {
  229.         strip.params.push(["THRESHOLD", cparams["threshold"], -100, 0, 100, false]);
  230.         strip.params.push(["KNEE", cparams["knee"], 0, 40, 40, false]);
  231.         strip.params.push(["RATIO", cparams["ratio"], 1, 20, 20, false]);
  232.         strip.params.push(["ATTACK", cparams["attack"], 0, 1, 1000, false]);
  233.         strip.params.push(["RELEASE", cparams["release"], 0, 1, 1000, false]);
  234.     }
  236.     strip.params.push(["VOLUME", m_sfx.get_volume(null), 0, 1, 50, false]);
  238.     strip.mute = m_sfx.is_muted(null) ? 1 : 0;
  239.     strip.solo = -1;
  241.     return strip;
  242. }
  244. function init_strip(id) {
  245.     return {
  246.         id : id,
  247.         params : [],
  248.         active_param : 0,
  249.         mute: -1,
  250.         solo: -1,
  251.         speaker: null
  252.     }
  253. }
  255. function create_speaker_strip(spk) {
  256.     var strip = init_strip(m_scenes.get_object_name(spk));
  257.     strip.mute = m_sfx.is_muted(spk) ? 1 : 0;
  258.     strip.solo = 0;
  259.     strip.speaker = spk;
  260.     return strip;
  261. }
  263. function switch_strip(dir) {
  264.     if (!_mixer_strips.length)
  265.         return;
  267.     if (dir == 1 && _active_strip < (_mixer_strips.length - 1)) {
  268.         _active_strip++;
  269.     } else if (dir == -1 && _active_strip > 0) {
  270.         _active_strip--;
  271.     }
  273.     var strip_range = active_strip_range();
  274.     for (var i = strip_range[0]; i <= strip_range[1]; i++)
  275.         update_strip_params(_mixer_strips[i]);
  276. }
  278. function update_strip_params(strip) {
  280.     if (!strip.speaker)
  281.         return;
  283.     // cleanup
  284.     strip.params.length = 0;
  286.     var pparams = m_sfx.get_positional_params(strip.speaker);
  287.     if (pparams) {
  288.         strip.params.push(["DIST_REF", pparams["dist_ref"], 0, 1000, 10000, false]);
  289.         strip.params.push(["ATTENUATION", pparams["attenuation"], 0, 50, 1000, false]);
  290.         strip.params.push(["DIST_MAX", pparams["dist_max"], 0, 10000, 10000, false]);
  291.     }
  293.     var fparams = m_sfx.get_filter_params(strip.speaker);
  294.     if (fparams) {
  295.         strip.params.push(["EQ_FREQ", fparams["freq"], 20, 20000, 100, true]);
  296.         strip.params.push(["EQ_Q", fparams["Q"], 0, 10, 100, false]);
  297.         strip.params.push(["EQ_GAIN", fparams["gain"], -70, 30, 100, false]);
  298.     }
  300.     strip.params.push(["VOLUME", m_sfx.get_volume(strip.speaker), 0, 1, 50, false]);
  302.     // handle params decrease
  303.     m_util.clamp(strip.active_param, 0, strip.params.length - 1);
  304. }
  306. function switch_param(dir) {
  307.     var strip = _mixer_strips[_active_strip];
  308.     if (!strip)
  309.         return;
  311.     if (dir == 1 && strip.active_param < (strip.params.length - 1)) {
  312.         strip.active_param++;
  313.     } else if (dir == -1 && strip.active_param > 0) {
  314.         strip.active_param--;
  315.     }
  316. }
  318. function param_inc_dec(dir) {
  319.     var strip = _mixer_strips[_active_strip];
  320.     if (!strip)
  321.         return;
  323.     var param = strip.params[strip.active_param];
  325.     if (param[5])
  326.         param[1] *= Math.pow(param[3] / param[2], dir / param[4]);
  327.     else
  328.         param[1] += dir * ((param[3] - param[2]) / param[4]);
  330.     param[1] = m_util.clamp(param[1], param[2], param[3]);
  332.     switch (param[0]) {
  333.     case "VOLUME":
  334.         if (strip.id != "MASTER")
  335.             m_sfx.set_volume(strip.speaker, param[1]);
  336.         else
  337.             m_sfx.set_volume(null, param[1]);
  338.         break;
  339.     case "DIST_REF":
  340.         var pparams = m_sfx.get_positional_params(strip.speaker);
  341.         pparams["dist_ref"] = param[1];
  342.         m_sfx.set_positional_params(strip.speaker, pparams);
  343.         break;
  344.     case "ATTENUATION":
  345.         var pparams = m_sfx.get_positional_params(strip.speaker);
  346.         pparams["attenuation"] = param[1];
  347.         m_sfx.set_positional_params(strip.speaker, pparams);
  348.         break;
  349.     case "DIST_MAX":
  350.         var pparams = m_sfx.get_positional_params(strip.speaker);
  351.         pparams["dist_max"] = param[1];
  352.         m_sfx.set_positional_params(strip.speaker, pparams);
  353.         break;
  355.     case "EQ_FREQ":
  356.         var fparams = m_sfx.get_filter_params(strip.speaker);
  357.         fparams["freq"] = param[1];
  358.         m_sfx.set_filter_params(strip.speaker, fparams);
  359.         break;
  360.     case "EQ_Q":
  361.         var fparams = m_sfx.get_filter_params(strip.speaker);
  362.         fparams["Q"] = param[1];
  363.         m_sfx.set_filter_params(strip.speaker, fparams);
  364.         break;
  365.     case "EQ_GAIN":
  366.         var fparams = m_sfx.get_filter_params(strip.speaker);
  367.         fparams["gain"] = param[1];
  368.         m_sfx.set_filter_params(strip.speaker, fparams);
  369.         break;
  371.     case "THRESHOLD":
  372.         var cparams = m_sfx.get_compressor_params();
  373.         cparams["threshold"] = param[1];
  374.         m_sfx.set_compressor_params(cparams);
  375.         break;
  376.     case "KNEE":
  377.         var cparams = m_sfx.get_compressor_params();
  378.         cparams["knee"] = param[1];
  379.         m_sfx.set_compressor_params(cparams);
  380.         break;
  381.     case "RATIO":
  382.         var cparams = m_sfx.get_compressor_params();
  383.         cparams["ratio"] = param[1];
  384.         m_sfx.set_compressor_params(cparams);
  385.         break;
  386.     case "ATTACK":
  387.         var cparams = m_sfx.get_compressor_params();
  388.         cparams["attack"] = param[1];
  389.         m_sfx.set_compressor_params(cparams);
  390.         break;
  391.     case "RELEASE":
  392.         var cparams = m_sfx.get_compressor_params();
  393.         cparams["release"] = param[1];
  394.         m_sfx.set_compressor_params(cparams);
  395.         break;
  396.     default:
  397.         m_print.error("Unknown strip param");
  398.         break;
  399.     }
  400. }
  402. function switch_mute() {
  403.     var strip = _mixer_strips[_active_strip];
  404.     if (!strip)
  405.         return;
  407.     if (strip.mute >= 0) {
  408.         flip_strip_mute(strip);
  409.     }
  410. }
  412. function flip_strip_mute(strip) {
  413.     var id = strip.id;
  415.     if (id != "MASTER") {
  416.         if (strip.mute == 0) {
  417.             strip.mute = 1;
  419.             m_sfx.mute(strip.speaker, true);
  421.             if (strip.solo == 1) {
  422.                 strip.solo = 0;
  424.                 if (!is_other_solo(strip))
  425.                     unmute_other(strip);
  426.             }
  427.         } else {
  428.             strip.mute = 0;
  430.             if (!is_other_solo(strip))
  431.                 m_sfx.mute(strip.speaker, false);
  432.         }
  433.     } else {
  434.         if (strip.mute == 0) {
  435.             strip.mute = 1;
  436.             m_sfx.mute(null, true);
  437.         } else {
  438.             strip.mute = 0;
  439.             m_sfx.mute(null, false);
  440.         }
  441.     }
  442. }
  444. function is_other_solo(strip) {
  445.     for (var i = 0; i < _mixer_strips.length; i++) {
  446.         var strip_i = _mixer_strips[i];
  448.         if (strip_i != strip && strip_i.solo == 1)
  449.             return true;
  450.     }
  451.     return false;
  452. }
  454. function mute_other(strip) {
  455.     for (var i = 0; i < _mixer_strips.length; i++) {
  456.         var strip_i = _mixer_strips[i];
  458.         if (strip_i != strip && strip_i.mute == 0 && strip_i.solo == 0)
  459.             m_sfx.mute(strip_i.speaker, true);
  460.     }
  461. }
  463. function unmute_other(strip) {
  464.     for (var i = 0; i < _mixer_strips.length; i++) {
  465.         var strip_i = _mixer_strips[i];
  467.         if (strip_i != strip && strip_i.mute == 0 && strip_i.solo == 0)
  468.             m_sfx.mute(strip_i.speaker, false);
  469.     }
  470. }
  472. function switch_solo() {
  473.     var strip = _mixer_strips[_active_strip];
  474.     if (!strip)
  475.         return;
  477.     if (strip.solo >= 0) {
  478.         flip_strip_solo(strip);
  479.     }
  480. }
  482. function flip_strip_solo(strip) {
  484.     if (strip.solo == 0) {
  485.         strip.solo = 1;
  487.         m_sfx.mute(strip.speaker, false);
  489.         // flip muted current
  490.         if (strip.mute == 1)
  491.             strip.mute = 0;
  493.         mute_other(strip);
  495.     } else {
  496.         strip.solo = 0;
  498.         if (is_other_solo(strip))
  499.             m_sfx.mute(strip.speaker, true);
  500.         else
  501.             unmute_other(strip);
  502.     }
  503. }
  505. function draw() {
  506.     if (!_mixer_strips[_active_strip])
  507.         return;
  509.     var strip_range = active_strip_range();
  511.     for (var i = strip_range[0]; i <= strip_range[1]; i++) {
  513.         var strip = _mixer_strips[i];
  515.         m_screen.draw_mixer_strip(strip.id, i == _active_strip, i % 8,
  516.                 strip.params, strip.active_param, strip.mute, strip.solo);
  518.         if (strip.speaker && m_sfx.get_filter_params(strip.speaker)) {
  519.             m_sfx.get_filter_freq_response(strip.speaker, _filter_freq_arr,
  520.                     _filter_mag_arr, _filter_phase_arr);
  522.             for (var j = 0; j < _filter_mag_arr.length; j++) {
  523.                 var mag = _filter_mag_arr[j];
  524.                 // log10()
  525.                 _filter_mag_arr[j] = 20 * Math.log(mag) / Math.LN10;
  526.             }
  528.             m_screen.plot_array("EQ", i % 8, _filter_mag_arr, 20, 20000, -10, 10);
  529.         }
  530.     }
  531. }
  533. function active_strip_range() {
  535.     if (_mixer_strips.length == 0)
  536.         return [0, -1];
  538.     var strip_low = Math.floor(_active_strip / 8) * 8;
  539.     var strip_high = strip_low + 7;
  541.     strip_low = m_util.clamp(strip_low, 0, _mixer_strips.length-1);
  542.     strip_high = m_util.clamp(strip_high, 0, _mixer_strips.length-1);
  544.     return [strip_low, strip_high];
  545. }
  548. }
  550. var mixer_factory = register("mixer", Mixer);
  552. export default mixer_factory;