feat: add tone correction PEQ sliders

app.py

@@ -10,6 +10,7 @@ import pyloudnorm as pyln
 from hydra.utils import instantiate
 from soxr import resample
 from functools import partial, reduce
+from itertools import accumulate
 from torchcomp import coef2ms, ms2coef
 from copy import deepcopy
 
@@ -626,6 +627,7 @@ with gr.Blocks() as demo:
                 plot_delay(fx), label="Delay Frequency Response", elem_id="delay-plot"
             )
 
+    _ = gr.Markdown("## FDN Reverb")
     with gr.Row():
         reverb_plot = gr.Plot(
             plot_reverb(fx),
@@ -637,6 +639,54 @@ with gr.Blocks() as demo:
             plot_t60(fx), label="Reverb T60", elem_id="t60-plot", min_width=160
         )
 
+    with gr.Row():
+        fdn = fx[7].effects[1]
+        tone_correct_peq = fdn.eq
+        with gr.Column(min_width=160):
+            _ = gr.Markdown("Low Shelf")
+            tc_ls = tone_correct_peq[2]
+            tc_ls_freq = default_freq_slider(
+                minimum=30, maximum=450, value=tc_ls.params.freq.item()
+            )
+            tc_ls_gain = default_gain_slider(
+                minimum=-12, maximum=12, value=tc_ls.params.gain.item()
+            )
+
+        with gr.Column(min_width=160):
+            _ = gr.Markdown("Peak filter 1")
+            tc_pk1 = tone_correct_peq[0]
+            tc_pk1_freq = default_freq_slider(
+                minimum=200, maximum=2500, value=tc_pk1.params.freq.item()
+            )
+            tc_pk1_gain = default_gain_slider(
+                minimum=-12, maximum=12, value=tc_pk1.params.gain.item()
+            )
+            tc_pk1_q = default_q_slider(
+                minimum=0.1, maximum=3, value=tc_pk1.params.Q.item()
+            )
+        with gr.Column(min_width=160):
+            _ = gr.Markdown("Peak filter 2")
+            tc_pk2 = tone_correct_peq[1]
+            tc_pk2_freq = default_freq_slider(
+                minimum=600, maximum=7000, value=tc_pk2.params.freq.item()
+            )
+            tc_pk2_gain = default_gain_slider(
+                minimum=-12, maximum=12, value=tc_pk2.params.gain.item()
+            )
+            tc_pk2_q = default_q_slider(
+                minimum=0.1, maximum=3, value=tc_pk2.params.Q.item()
+            )
+
+        with gr.Column(min_width=160):
+            _ = gr.Markdown("High Shelf")
+            tc_hs = tone_correct_peq[3]
+            tc_hs_freq = default_freq_slider(
+                minimum=1500, maximum=16000, value=tc_hs.params.freq.item()
+            )
+            tc_hs_gain = default_gain_slider(
+                minimum=-12, maximum=12, value=tc_hs.params.gain.item()
+            )
+
     with gr.Row():
         json_output = gr.JSON(
             model2json(fx), label="Effect Settings", max_height=800, open=True
@@ -705,14 +755,38 @@ with gr.Blocks() as demo:
     ]
     delay_update_plot_flag = [True] * 4 + [False] * 2
 
-    all_effect_sliders = peq_sliders + cmp_sliders + delay_sliders + [reverb_send]
-    split_sizes = [len(peq_sliders), len(cmp_sliders), len(delay_sliders), 1]
+    tc_peq_sliders = [
+        tc_pk1_freq,
+        tc_pk1_gain,
+        tc_pk1_q,
+        tc_pk2_freq,
+        tc_pk2_gain,
+        tc_pk2_q,
+        tc_ls_freq,
+        tc_ls_gain,
+        tc_hs_freq,
+        tc_hs_gain,
+    ]
+    tc_peq_attr_names = ["freq", "gain", "Q"] * 2 + ["freq", "gain"] * 2
+    tc_peq_indices = [0] * 3 + [1] * 3 + [2] * 2 + [3] * 2
+
+    all_effect_sliders = (
+        peq_sliders + cmp_sliders + delay_sliders + tc_peq_sliders + [reverb_send]
+    )
+    split_sizes = [
+        len(peq_sliders),
+        len(cmp_sliders),
+        len(delay_sliders),
+        len(tc_peq_sliders),
+        1,
+    ]
+    split_indexes = list(
+        accumulate(split_sizes, initial=0)
+    )  # [0, len(peq_sliders), len(peq_sliders) + len(cmp_sliders), ...]
 
     def assign_fx_params(fx, *args):
-        peq_sliders, cmp_sliders, delay_sliders = (
-            args[: split_sizes[0]],
-            args[split_sizes[0] : sum(split_sizes[:2])],
-            args[sum(split_sizes[:2]) : -1],
+        peq_sliders, cmp_sliders, delay_sliders, tc_peq_sliders = map(
+            lambda i, j: args[i:j], split_indexes[:-2], split_indexes[1:-1]
         )
         reverb_send_slider = args[-1]
         for idx, s, attr_name in zip(peq_indices, peq_sliders, peq_attr_names):
@@ -725,6 +799,9 @@ with gr.Blocks() as demo:
             m, name = get_last_attribute(fx[7].effects[0], attr_name)
             f(m, name, s)
 
+        for idx, s, attr_name in zip(tc_peq_indices, tc_peq_sliders, tc_peq_attr_names):
+            update_param(fx[7].effects[1].eq[idx].params, attr_name, s)
+
         update_param(fx[7].params, "sends_0", 10 ** (reverb_send_slider / 20))
 
         return fx
@@ -792,6 +869,18 @@ with gr.Blocks() as demo:
         outputs=[z, fx_params, json_output] + update_pc_outputs,
     )
 
+    for s in tc_peq_sliders:
+        s.input(
+            chain_functions(
+                lambda x, i, *args: x2z_common_steps(x, *args) + (i,),
+                lambda z, x, fx, e_pc_i: [z, x]
+                + [model2json(fx), plot_reverb(fx)]
+                + update_pc(z, e_pc_i),
+            ),
+            inputs=[fx_params, extra_pc_dropdown] + all_effect_sliders,
+            outputs=[z, fx_params, json_output, reverb_plot] + update_pc_outputs,
+        )
+
     render_button.click(
         chain_functions(
             lambda audio, ratio, x, *all_s: (
@@ -843,6 +932,16 @@ with gr.Blocks() as demo:
         fx[7].effects[0].odd_pan.params.pan.item() * 200 - 100,
         fx[7].effects[0].even_pan.params.pan.item() * 200 - 100,
         fx[7].params.sends_0.log10().item() * 20,
+        fx[7].effects[1].eq[0].params.freq.item(),
+        fx[7].effects[1].eq[0].params.gain.item(),
+        fx[7].effects[1].eq[0].params.Q.item(),
+        fx[7].effects[1].eq[1].params.freq.item(),
+        fx[7].effects[1].eq[1].params.gain.item(),
+        fx[7].effects[1].eq[1].params.Q.item(),
+        fx[7].effects[1].eq[2].params.freq.item(),
+        fx[7].effects[1].eq[2].params.gain.item(),
+        fx[7].effects[1].eq[3].params.freq.item(),
+        fx[7].effects[1].eq[3].params.gain.item(),
     ]
     update_fx_outputs = [
         pk1_freq,
@@ -873,6 +972,16 @@ with gr.Blocks() as demo:
         odd_pan,
         even_pan,
         reverb_send,
+        tc_pk1_freq,
+        tc_pk1_gain,
+        tc_pk1_q,
+        tc_pk2_freq,
+        tc_pk2_gain,
+        tc_pk2_q,
+        tc_ls_freq,
+        tc_ls_gain,
+        tc_hs_freq,
+        tc_hs_gain,
     ]
     update_plots = lambda fx: [
         plot_eq(fx),