Function run_flow_chunk

src/models/heartmula/codec.cpp:1596–1654

    if (static_cast<int64_t>(true_latents.size()) != latent_length * config.out_channels) {
        throw std::runtime_error("HeartCodec true-latent payload shape mismatch");
    }
    for (int64_t t = 0; t < incontext_length; ++t) {
        std::copy(
            true_latents.begin() + static_cast<std::ptrdiff_t>(t * config.out_channels),
            true_latents.begin() + static_cast<std::ptrdiff_t>((t + 1) * config.out_channels),
            incontext.begin() + static_cast<std::ptrdiff_t>(t * config.out_channels));
    }
    auto solved = solve_euler(
        runtime,
        std::move(latents),
        incontext,
        incontext_length,
        conditioning.values,
        num_steps,
        guidance_scale);
    for (int64_t t = 0; t < incontext_length; ++t) {
        std::copy(
            incontext.begin() + static_cast<std::ptrdiff_t>(t * config.out_channels),
            incontext.begin() + static_cast<std::ptrdiff_t>((t + 1) * config.out_channels),
            solved.begin() + static_cast<std::ptrdiff_t>(t * config.out_channels));
    }
    return solved;
}

std::vector<float> latent_btc_to_scalar_bct(const std::vector<float> & latent_btc, int64_t frames) {
    const int64_t channels = 2;
    const int64_t latent_hidden = 128;
    if (static_cast<int64_t>(latent_btc.size()) != frames * channels * latent_hidden) {
        throw std::runtime_error("HeartCodec latent reshape payload mismatch");
    }
    std::vector<float> out(static_cast<size_t>(channels * latent_hidden * frames), 0.0F);
    for (int64_t t = 0; t < frames; ++t) {
        for (int64_t stream = 0; stream < channels; ++stream) {
            for (int64_t dim = 0; dim < latent_hidden; ++dim) {
                const size_t src = static_cast<size_t>(t * channels * latent_hidden + stream * latent_hidden + dim);
                const size_t dst = static_cast<size_t>((stream * latent_hidden + dim) * frames + t);
                out[dst] = latent_btc[src];
            }
        }
    }
    return out;
}

std::vector<float> decoded_batch_to_stereo(
    const HeartCodecDecodedAudio & decoded,
    int64_t samples) {
    if (decoded.batch_size != 2 || decoded.channels != 1 || decoded.samples < samples) {
        throw std::runtime_error("HeartCodec scalar decoder output shape mismatch");
    }
    std::vector<float> out(static_cast<size_t>(2 * samples), 0.0F);
    for (int64_t ch = 0; ch < 2; ++ch) {
        std::copy(
            decoded.values.begin() + static_cast<std::ptrdiff_t>(ch * decoded.samples),
            decoded.values.begin() + static_cast<std::ptrdiff_t>(ch * decoded.samples + samples),
            out.begin() + static_cast<std::ptrdiff_t>(ch * samples));
    }
    return out;
}