Class S3GenSessionCache::State

src/models/chatterbox/s3gen_inference.cpp:344–428

    }
    const int64_t keep = std::min<int64_t>(static_cast<int64_t>(waveform.size()), fade_size);
    for (int64_t i = 0; i < std::min<int64_t>(keep, n_trim); ++i) {
        waveform[static_cast<size_t>(i)] = 0.0f;
    }
    constexpr double kPi = 3.141592653589793238462643383279502884;
    for (int64_t i = n_trim; i < keep; ++i) {
        const double alpha = static_cast<double>(i - n_trim) / static_cast<double>(std::max<int64_t>(n_trim - 1, 1));
        const float fade = static_cast<float>((std::cos(kPi * (1.0 - alpha)) + 1.0) / 2.0);
        waveform[static_cast<size_t>(i)] *= fade;
    }
}

}  // namespace

struct S3GenSessionCache::State {
    explicit State(engine::core::BackendConfig backend_value)
        : backend(std::move(backend_value)),
          token_capacity_controller(runtime::GraphCapacityMode::Grow),
          flow_cache(backend) {}

    struct PreparedCapacity {
        int64_t token_capacity = 0;
        int64_t frame_capacity = 0;
        std::unique_ptr<S3TokenEmbeddingGraph> token_embedding;
        std::unique_ptr<S3Token2MelPrepareGraph> token2mel_prepare;
    };

    runtime::MappedGraphCapacityAdapter make_token_capacity_adapter(
        const S3FlowEncoderWeights & weights,
        const engine::core::BackendConfig & backend_config) {
        const int64_t quantum = token_capacity_quantum(backend_config);
        return runtime::MappedGraphCapacityAdapter(
            quantum,
            quantum,
            [quantum](int64_t request_size) {
                return round_up_capacity(request_size, quantum);
            },
            [this]() {
                std::vector<int64_t> capacities;
                if (prepared_capacity.token_embedding && prepared_capacity.token2mel_prepare) {
                    capacities.push_back(prepared_capacity.token_capacity);
                }
                return capacities;
            },
            [this, &weights](int64_t capacity) {
                prepare_token_capacity(weights, capacity);
            });
    }

    void prepare_token_capacity(
        const S3FlowEncoderWeights & weights,
        int64_t token_capacity) {
        if (token_capacity <= 0) {
            throw std::runtime_error("S3 token capacity must be positive");
        }
        if (prepared_capacity.token_embedding &&
            prepared_capacity.token2mel_prepare &&
            prepared_capacity.token_capacity == token_capacity) {
            return;