Method run

src/models/heartmula/codec.cpp:998–1025

    }

    HeartCodecFlowEstimate run(
        const std::vector<float> & hidden_states,
        const std::vector<float> & timesteps) {
        allocate_workspace();
        const auto & config = runtime_->assets().codec_config;
        const size_t expected_hidden = static_cast<size_t>(batch_size_ * frames_ * config.in_channels);
        if (hidden_states.size() != expected_hidden) {
            throw std::runtime_error("HeartCodec flow estimator hidden-state payload size mismatch");
        }
        if (static_cast<int64_t>(timesteps.size()) != batch_size_) {
            throw std::runtime_error("HeartCodec flow estimator timestep payload size mismatch");
        }
        ggml_backend_tensor_set(input_, hidden_states.data(), 0, hidden_states.size() * sizeof(float));
        ggml_backend_tensor_set(timesteps_, timesteps.data(), 0, timesteps.size() * sizeof(float));
        core::set_backend_threads(runtime_->backend(), runtime_->threads());
        const ggml_status status = core::compute_backend_graph(runtime_->backend(), graph_);
        ggml_backend_synchronize(runtime_->backend());
        if (status != GGML_STATUS_SUCCESS) {
            throw std::runtime_error("HeartCodec flow estimator graph compute failed");
        }
        HeartCodecFlowEstimate out;
        out.batch_size = batch_size_;
        out.frames = frames_;
        out.channels = config.out_channels;
        out.values.resize(static_cast<size_t>(out.batch_size * out.frames * out.channels));
        ggml_backend_tensor_get(output_, out.values.data(), 0, out.values.size() * sizeof(float));
        return out;
    }

private:
    void allocate_workspace() {