How I can fade the cut off frequency level of an LPF filter?

[dortamiguel]

I will like to be a be able to smoothly fade the cutt off frequency of an lpf node.

I'm trying already to do this by manually calling ma_lpf_node_reinit every 1 millisecond with an updated cutoffFrequency value, but so far the result I got is not good. In the following video you can see how some noise appears when the cut off changes very fast.

Kapture_2024-07-15_at_21.18.53.mp4

This is how the implementation I have looks like

// miniaudio.h state
ma_engine engine;
const u16 MAX_SOUND_COUNT = 2048;
std::array<ma_sound, MAX_SOUND_COUNT> miniaudio_sounds;

ma_lpf_node_config low_pass_filter_node_config;
ma_lpf_config low_pass_filter_config;
ma_lpf_node low_pass_filter_node;
double previous_cut_off_frequency = 0.;

// intialize engine
ma_engine_init(nullptr, &engine)

channels = ma_engine_get_channels(&engine);
sample_rate = ma_engine_get_sample_rate(&engine);

previous_cut_off_frequency = MAX_FREQUENCY;
low_pass_filter_node_config =
    ma_lpf_node_config_init(channels, sample_rate, MAX_FREQUENCY, MA_MAX_FILTER_ORDER);
ma_lpf_node_init(
    ma_engine_get_node_graph(&engine), &low_pass_filter_node_config, NULL, &low_pass_filter_node
);
ma_node_attach_output_bus(&low_pass_filter_node, 0, ma_engine_get_endpoint(&engine), 0);

This is how I'm loading every sound so I can have a global low pass filter

// attach every sound to the low pass filter node
void Audio::load_source(string &sound_path) {
    if (ma_sound_init_from_file(
            &engine,
            sound_path.c_str(),
            MA_SOUND_FLAG_STREAM,
            nullptr,
            nullptr,
            &miniaudio_sounds[sound_count]
        ) != MA_SUCCESS) {
        quit("ma_sound_init_from_file error: can't load sound " + sound_path);
    }
    ma_node_attach_output_bus(&miniaudio_sounds[sound_count], 0, &low_pass_filter_node, 0);
    sound_count += 1;
}

I have an update function that will detect if the cut_off_frequency has changed

void Sounds::update() {
    audio.cut_off_frequency = clamp(audio.cut_off_frequency, MIN_FREQUENCY, MAX_FREQUENCY);
    if (!equals(previous_cut_off_frequency, audio.cut_off_frequency)) {
        previous_cut_off_frequency = audio.cut_off_frequency;
        low_pass_filter_config = ma_lpf_config_init(
            ma_format_f32,
            audio.channels,
            audio.sample_rate,
            audio.cut_off_frequency,
            MA_MAX_FILTER_ORDER
        );
        ma_lpf_node_reinit(&low_pass_filter_config, &low_pass_filter_node);
    }
}

Finally in another thread I update audio.cut_off_frequency listening for changes

auto audio_loop = [&]() {
    while (!input.exit) {
        wait(1);
        audio.cut_off_frequency =
            lerp(menu.cut_off_frequency, MAX_FREQUENCY, 1. - (double)menu.view.style.alpha);
    }
};
std::thread(audio_loop).detach();

[mackron]

The LPF node was never designed to do smooth transitions like that. I think your best bet might actually be to have two LPFs and then do a cross-fade between the two. The complication is that you won't be able to do that easily with any of the stock nodes. You would need to implement a custom node and do it yourself (there is a ma_lpf object that can help you out, which is what ma_lpf_node uses under the hood). I can't think of another way to do it off the top of my head.

[dortamiguel]

@mackron thank you that is a nice idea

I recently found in the discord that setting the order to 1 won't get this issue, so now I'm using that and it seems fine at least on macos. I need to test other platforms