Function separate_runtime_chunk

src/models/roformer/runtime.cpp:892–940

    #pragma omp parallel for collapse(2) if(channels * freq_bins >= 512)
#endif
    for (int64_t ch = 0; ch < channels; ++ch) {
        for (int64_t freq = 0; freq < freq_bins; ++freq) {
            for (int64_t frame_index = 0; frame_index < frames; ++frame_index) {
                const size_t src = static_cast<size_t>((((ch * freq_bins) + freq) * frames + frame_index) * 2);
                spectrum[static_cast<size_t>(((ch * freq_bins) + freq) * frames + frame_index)] = {
                    complex_spec[src],
                    complex_spec[src + 1],
                };
            }
        }
    }

    engine::audio::TensorShape output_shape{
        static_cast<size_t>(channels),
        static_cast<size_t>(config.n_fft),
        static_cast<size_t>(frames),
    };
    engine::audio::TensorStrideBytes input_strides{
        static_cast<std::ptrdiff_t>(freq_bins * frames * static_cast<int64_t>(sizeof(std::complex<float>))),
        static_cast<std::ptrdiff_t>(frames * static_cast<int64_t>(sizeof(std::complex<float>))),
        static_cast<std::ptrdiff_t>(sizeof(std::complex<float>)),
    };
    engine::audio::TensorStrideBytes output_strides{
        static_cast<std::ptrdiff_t>(config.n_fft * frames * static_cast<int64_t>(sizeof(float))),
        static_cast<std::ptrdiff_t>(frames * static_cast<int64_t>(sizeof(float))),
        static_cast<std::ptrdiff_t>(sizeof(float)),
    };

    std::vector<float> framed(static_cast<size_t>(channels * config.n_fft * frames), 0.0f);
    engine::audio::real_fft_inverse(
        output_shape,
        input_strides,
        output_strides,
        1,
        spectrum.data(),
        framed.data(),
        1.0f / static_cast<float>(config.n_fft),
        threads);

    const int64_t pad = config.center ? config.n_fft / 2 : 0;
    const int64_t padded_samples = samples + 2 * pad;
    const int64_t usable_window = std::min<int64_t>(config.win_length, config.n_fft);
    const int64_t window_offset = (config.n_fft - config.win_length) / 2;
    std::vector<float> window_sq(static_cast<size_t>(usable_window), 0.0f);
#ifdef _OPENMP
    #pragma omp parallel for if(usable_window >= 256)
#endif
    for (int64_t i = 0; i < usable_window; ++i) {
        const float w = window[static_cast<size_t>(i)];
        window_sq[static_cast<size_t>(i)] = w * w;
    }