Method run

src/models/demucs/session.cpp:208–326

    const engine::audio::AudioChunkSpec chunk_spec{
        chunk_size_,
        step_,
        engine::audio::AudioChunkPadMode::Zero,
        engine::audio::AudioChunkTailAlignment::Center,
        0,
    };
    std::vector<float> merge_window(static_cast<size_t>(chunk_size_), 0.0F);
    for (const auto & chunk : engine::audio::plan_audio_chunks(total_frames, chunk_spec)) {
        const auto copy_start = std::chrono::steady_clock::now();
        engine::audio::copy_interleaved_chunk_to_planar(
            chunk_planar_work_,
            audio.samples,
            audio.channels,
            total_frames,
            chunk,
            chunk_spec);
        const auto copy_end = std::chrono::steady_clock::now();
        chunk_copy_ms += debug::elapsed_ms(copy_start, copy_end);
        const auto & chunk_sources = pipeline_->separate_chunk(chunk_planar_work_);
        const auto & timing = pipeline_->last_timing();
        frontend_ms += timing.frontend_ms;
        graph_ms += timing.graph_ms;
        postprocess_ms += timing.postprocess_ms;
        graph_rebuild_ms += timing.graph_rebuild_ms;
        const int64_t trim_offset = chunk.valid_start_in_chunk;
        const auto merge_start = std::chrono::steady_clock::now();
        std::fill(merge_window.begin(), merge_window.end(), 0.0F);
        for (int64_t i = 0; i < chunk.valid_samples; ++i) {
            merge_window[static_cast<size_t>(trim_offset + i)] = chunk_window_[static_cast<size_t>(i)];
        }
        engine::audio::overlap_add_planar_chunk(
            result_work_,
            counter_work_,
            chunk_sources,
            num_sources * audio.channels,
            total_frames,
            chunk,
            merge_window,
            engine::audio::AudioChunkCounterMode::SharedAcrossLanes);
        merge_ms += debug::elapsed_ms(merge_start);
    }

    runtime::TaskResult result;
    for (int source = 0; source < num_sources; ++source) {
        runtime::NamedAudioBuffer named;
        named.id = config.sources[static_cast<size_t>(source)];
        named.audio.sample_rate = audio.sample_rate;
        named.audio.channels = original_mono ? 1 : audio.channels;
        if (original_mono) {
            named.audio.samples.resize(static_cast<size_t>(total_frames));
            for (int64_t i = 0; i < total_frames; ++i) {
                const float denom = counter_work_[static_cast<size_t>(i)] > 1.0e-8f
                    ? counter_work_[static_cast<size_t>(i)]
                    : 1.0f;
                const float * src = result_work_.data() + static_cast<size_t>((source * audio.channels) * total_frames);
                named.audio.samples[static_cast<size_t>(i)] = src[i] / denom * global_std + global_mean;
            }
        } else {
            named.audio.samples.resize(static_cast<size_t>(audio.channels * total_frames));