Function apply_activity_gate_in_place

src/framework/audio/mixing.cpp:99–186

}

void apply_activity_gate_in_place(
    std::vector<float> & samples,
    const std::vector<float> & reference,
    int channels,
    int sample_rate,
    float threshold_dbfs,
    double window_seconds,
    double margin_seconds,
    double fade_seconds) {
    if (channels <= 0 || sample_rate <= 0 || window_seconds <= 0.0 || margin_seconds < 0.0 || fade_seconds < 0.0) {
        throw std::runtime_error("audio activity gate received invalid parameters");
    }
    if (samples.size() != reference.size() || samples.size() % static_cast<size_t>(channels) != 0) {
        throw std::runtime_error("audio activity gate requires matching input and reference shapes");
    }
    const int64_t frames = static_cast<int64_t>(samples.size() / static_cast<size_t>(channels));
    if (frames <= 0) {
        return;
    }
    const int64_t window_frames =
        std::max<int64_t>(1, static_cast<int64_t>(std::llround(window_seconds * static_cast<double>(sample_rate))));
    const int64_t margin_frames =
        std::max<int64_t>(0, static_cast<int64_t>(std::llround(margin_seconds * static_cast<double>(sample_rate))));
    const int64_t fade_frames =
        std::max<int64_t>(0, static_cast<int64_t>(std::llround(fade_seconds * static_cast<double>(sample_rate))));
    const double threshold = std::pow(10.0, static_cast<double>(threshold_dbfs) / 20.0);
    const double threshold_energy = threshold * threshold;
    std::vector<uint8_t> active(static_cast<size_t>(frames), 0);
    for (int64_t window_start = 0; window_start < frames; window_start += window_frames) {
        const int64_t window_end = std::min(frames, window_start + window_frames);
        double energy = 0.0;
        int64_t count = 0;
        for (int64_t frame = window_start; frame < window_end; ++frame) {
            const size_t base = static_cast<size_t>(frame * channels);
            for (int channel = 0; channel < channels; ++channel) {
                const float sample = reference[base + static_cast<size_t>(channel)];
                energy += static_cast<double>(sample) * static_cast<double>(sample);
                ++count;
            }
        }
        const double mean_energy = count > 0 ? energy / static_cast<double>(count) : 0.0;
        if (mean_energy > threshold_energy) {
            const int64_t begin = std::max<int64_t>(0, window_start - margin_frames);
            const int64_t end = std::min<int64_t>(frames, window_end + margin_frames);
            std::fill(
                active.begin() + static_cast<std::ptrdiff_t>(begin),
                active.begin() + static_cast<std::ptrdiff_t>(end),
                static_cast<uint8_t>(1));
        }
    }

    std::vector<int64_t> prev_active(static_cast<size_t>(frames), -1);
    std::vector<int64_t> next_active(static_cast<size_t>(frames), frames);
    int64_t prev = -1;
    for (int64_t frame = 0; frame < frames; ++frame) {
        if (active[static_cast<size_t>(frame)] != 0) {
            prev = frame;
        }