Method run

src/models/heartmula/mula.cpp:1585–1633

    }

    HeartMuLaMergedEmbeddings run(const HeartMuLaFrameEmbeddingInputs & inputs) {
        allocate_workspace();
        const auto & config = runtime_->assets().mula_config;
        const size_t audio_count = static_cast<size_t>(batch_size_ * steps_ * config.audio_num_codebooks);
        const size_t text_count = static_cast<size_t>(batch_size_ * steps_);
        if (inputs.batch_size != batch_size_ || inputs.steps != steps_) {
            throw std::runtime_error("HeartMuLa frame embedding input shape mismatch");
        }
        if (inputs.audio_token_ids.size() != audio_count || inputs.audio_mask.size() != audio_count ||
            inputs.text_token_ids.size() != text_count || inputs.text_cond_mask.size() != text_count ||
            inputs.text_uncond_mask.size() != text_count) {
            throw std::runtime_error("HeartMuLa frame embedding input payload size mismatch");
        }
        ggml_backend_tensor_set(audio_token_ids_, inputs.audio_token_ids.data(), 0, audio_count * sizeof(int32_t));
        ggml_backend_tensor_set(text_token_ids_, inputs.text_token_ids.data(), 0, text_count * sizeof(int32_t));
        ggml_backend_tensor_set(audio_mask_, inputs.audio_mask.data(), 0, audio_count * sizeof(float));
        ggml_backend_tensor_set(text_cond_mask_, inputs.text_cond_mask.data(), 0, text_count * sizeof(float));
        ggml_backend_tensor_set(text_uncond_mask_, inputs.text_uncond_mask.data(), 0, text_count * sizeof(float));
        if (apply_muq_) {
            if (!inputs.apply_muq || inputs.muq_row < 0 || inputs.muq_row >= steps_) {
                throw std::runtime_error("HeartMuLa frame embedding MuQ row is invalid");
            }
            if (inputs.muq_embed.size() != static_cast<size_t>(batch_size_ * config.muq_dim) ||
                inputs.muq_cond_mask.size() != static_cast<size_t>(batch_size_) ||
                inputs.muq_uncond_mask.size() != static_cast<size_t>(batch_size_)) {
                throw std::runtime_error("HeartMuLa frame embedding MuQ payload size mismatch");
            }
            const int32_t row = static_cast<int32_t>(inputs.muq_row);
            ggml_backend_tensor_set(muq_embed_, inputs.muq_embed.data(), 0, inputs.muq_embed.size() * sizeof(float));
            ggml_backend_tensor_set(muq_cond_mask_, inputs.muq_cond_mask.data(), 0, inputs.muq_cond_mask.size() * sizeof(float));
            ggml_backend_tensor_set(muq_uncond_mask_, inputs.muq_uncond_mask.data(), 0, inputs.muq_uncond_mask.size() * sizeof(float));
            ggml_backend_tensor_set(muq_row_, &row, 0, sizeof(int32_t));
        } else if (inputs.apply_muq) {
            throw std::runtime_error("HeartMuLa frame embedding graph was built without MuQ support");
        }
        core::set_backend_threads(runtime_->backend(), runtime_->threads());
        const ggml_status status = engine::core::compute_backend_graph(runtime_->backend(), graph_);
        ggml_backend_synchronize(runtime_->backend());
        if (status != GGML_STATUS_SUCCESS) {
            throw std::runtime_error("HeartMuLa frame embedding graph compute failed");
        }
        HeartMuLaMergedEmbeddings out;
        out.batch_size = batch_size_;
        out.steps = steps_;
        out.dims = config.backbone.embed_dim;
        out.values.resize(static_cast<size_t>(batch_size_ * steps_ * config.backbone.embed_dim));
        ggml_backend_tensor_get(output_, out.values.data(), 0, out.values.size() * sizeof(float));
        return out;
    }

private:
    void allocate_workspace() {