Method cached_step_batch

src/models/vibevoice/decoder.cpp:1689–1767

}

std::vector<VibeVoiceDecoderResult> VibeVoiceDecoderWeightsRuntime::cached_step_batch(
    const std::vector<std::vector<float>> & embeddings,
    const std::vector<VibeVoiceDecoderCachedState *> & states,
    int64_t cache_capacity) const {
    const auto & config = assets_->config.decoder;
    if (embeddings.empty()) {
        throw std::runtime_error("VibeVoice decoder cached batch step requires at least one sample");
    }
    if (embeddings.size() != states.size()) {
        throw std::runtime_error("VibeVoice decoder cached batch step state count mismatch");
    }
    if (cache_capacity <= 0) {
        throw std::runtime_error("VibeVoice decoder cached batch step requires positive cache capacity");
    }
    for (const auto & embedding : embeddings) {
        if (static_cast<int64_t>(embedding.size()) != config.hidden_size) {
            throw std::runtime_error("VibeVoice decoder cached batch step embedding payload size mismatch");
        }
    }
    for (auto * state : states) {
        if (state == nullptr) {
            throw std::runtime_error("VibeVoice decoder cached batch step received null state");
        }
    }
    if (embeddings.size() == 1) {
        return {cached_step(embeddings.front(), *states.front(), cache_capacity)};
    }

    auto state_current_end = [&](const VibeVoiceDecoderCachedState & state) -> int64_t {
        if (state.batch_owner_ != nullptr) {
            return find_cached_batch_graph(state)->current_end();
        }
        return state.graph_has_state_ && state.graph_ != nullptr
            ? state.graph_->current_end()
            : state.pending_state_.current_end;
    };

    const int64_t current_end = state_current_end(*states.front());
    for (auto * state : states) {
        if (state_current_end(*state) != current_end) {
            throw std::runtime_error("VibeVoice decoder cached batch step requires matching current_end");
        }
    }
    const int64_t required_capacity = cache_graph_capacity(
        std::max<int64_t>(cache_capacity, current_end + 1),
        config.max_position_embeddings);

    VibeVoiceDecoderCachedBatchStepGraph * graph = nullptr;
    for (const auto & candidate : cached_batch_graphs_) {
        if (candidate->matches(*this, states, required_capacity)) {
            graph = candidate.get();
            break;
        }
    }

    if (graph == nullptr) {
        std::vector<const VibeVoiceDecoderCachedBatchStepGraph *> owners;
        for (auto * state : states) {