Method encode

src/models/stable_audio/same_autoencoder.cpp:1336–1423

    engine::debug::timing_log_scalar("stable_audio.same_decode.host.output_pack_ms", output_pack_ms);
    std::vector<runtime::AudioBuffer> out;
    out.reserve(static_cast<size_t>(batch));
    for (int64_t b = 0; b < batch; ++b) {
        std::vector<float> interleaved(static_cast<size_t>(config.audio_channels * total_frames), 0.0F);
        for (int64_t frame = 0; frame < total_frames; ++frame) {
            for (int64_t c = 0; c < config.audio_channels; ++c) {
                interleaved[static_cast<size_t>(frame * config.audio_channels + c)] =
                    channel_major[static_cast<size_t>((b * config.audio_channels + c) * total_frames + frame)];
            }
        }
        out.push_back(runtime::AudioBuffer{config.sample_rate, static_cast<int>(config.audio_channels), std::move(interleaved)});
    }
    return out;
}

std::vector<float> StableAudioSameRuntime::encode(
    const runtime::AudioBuffer & audio,
    int64_t audio_sample_size,
    uint64_t seed,
    uint64_t & rng_offset_blocks) const {
    const auto & config = assets_->config;
    if (audio_sample_size <= 0 || audio_sample_size % config.downsampling_ratio != 0) {
        throw std::runtime_error("Stable Audio SAME encode audio_sample_size is invalid");
    }
    const auto & weights = require_same_weights(weights_, *execution_, assets_, weight_storage_type_);
    if (!encoder_graph_) {
        encoder_graph_ = std::make_unique<EncoderGraph>(*execution_, assets_, weights, weight_storage_type_);
    }
    const int64_t latent_tokens = audio_sample_size / config.downsampling_ratio;
    const int64_t patch_frames = audio_sample_size / config.pretransform_patch_size;
    auto prepared = adapt_interleaved_audio(
        audio,
        config.sample_rate,
        static_cast<int>(config.audio_channels),
        audio_sample_size);
    std::vector<int64_t> starts;
    if (latent_tokens <= kSameChunkLatents) {
        starts.push_back(0);
    } else {
        const int64_t hop = kSameChunkLatents - kSameChunkOverlap;
        for (int64_t start = 0; start <= latent_tokens - kSameChunkLatents; start += hop) {
            starts.push_back(start);
        }
        const int64_t final_start = latent_tokens - kSameChunkLatents;
        if (starts.empty() || starts.back() != final_start) {
            starts.push_back(final_start);
        }
    }
    std::vector<float> out(static_cast<size_t>(config.latent_dim * latent_tokens), 0.0F);
    const int64_t chunk_patch_frames = kSameChunkLatents * config.same_strides.front();
    std::vector<float> token_noise;
    for (size_t chunk_index = 0; chunk_index < starts.size(); ++chunk_index) {
        const int64_t latent_start = starts[chunk_index];
        const int64_t patch_start = latent_start * config.same_strides.front();
        std::vector<float> patched(static_cast<size_t>(config.same_encoder_in_channels * chunk_patch_frames), 0.0F);
        for (int64_t l = 0; l < chunk_patch_frames; ++l) {
            const int64_t src_patch = patch_start + l;
            if (src_patch >= patch_frames) {
                continue;