Method decode

src/models/stable_audio/same_autoencoder.cpp:1180–1334

    assets::TensorStorageType weight_storage_type) {
    if (!weights) {
        weights = std::make_unique<StableAudioSameWeights>(load_stable_audio_same_weights(
            *assets,
            execution.backend(),
            execution.backend_type(),
            0,
            weight_storage_type));
    }
    return *weights;
}

void StableAudioSameRuntime::prepare_decode(int64_t batch, int64_t latent_tokens, bool chunked) const {
    const auto & weights = require_same_weights(weights_, *execution_, assets_, weight_storage_type_);
    const int64_t graph_latents = decoder_graph_latents(assets_->config, latent_tokens, chunked);
    if (!graph_ || !graph_->matches(batch, graph_latents)) {
        graph_ = std::make_unique<Graph>(*execution_, assets_, weights, batch, graph_latents, weight_storage_type_);
    }
}

std::vector<runtime::AudioBuffer> StableAudioSameRuntime::decode(
    const std::vector<float> & latents,
    int64_t batch,
    int64_t latent_tokens,
    uint64_t seed,
    uint64_t & rng_offset_blocks,
    bool chunked) const {
    const auto & config = assets_->config;
    if (static_cast<int64_t>(latents.size()) != batch * config.latent_dim * latent_tokens) {
        throw std::runtime_error("Stable Audio SAME decode latent shape mismatch");
    }
    const int64_t graph_latents = decoder_graph_latents(config, latent_tokens, chunked);
    prepare_decode(batch, latent_tokens, chunked);
    std::vector<int64_t> starts;
    if (!chunked || 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);
        }
    }
    const int64_t frames_per_chunk = graph_latents * config.downsampling_ratio;
    const int64_t total_frames = latent_tokens * config.downsampling_ratio;
    std::vector<float> channel_major(static_cast<size_t>(batch * config.audio_channels * total_frames), 0.0F);
    std::vector<float> chunk_latent(static_cast<size_t>(batch * config.latent_dim * graph_latents), 0.0F);
    std::vector<float> bottleneck_noise(static_cast<size_t>(batch * config.latent_dim * graph_latents), 0.0F);
    std::vector<float> bottleneck_noise_source;
    std::vector<float> token_noise;
    double chunk_latent_ms = 0.0;
    double bottleneck_noise_ms = 0.0;
    double token_noise_ms = 0.0;
    double input_upload_ms = 0.0;
    double graph_compute_ms = 0.0;
    double output_read_ms = 0.0;
    double output_pack_ms = 0.0;