Method run

src/models/omnivoice/audio_tokenizer.cpp:1962–2005

    }

    OmniVoiceAudioTokens run(const NormalizedReferenceAudio & audio) {
        const int64_t actual_frames = audio.frames;
        if (static_cast<int64_t>(audio.acoustic_samples_24k.size()) > acoustic_sample_capacity_ ||
            static_cast<int64_t>(audio.semantic_samples_16k_padded.size()) > semantic_sample_capacity_ ||
            actual_frames > frame_capacity_) {
            throw std::runtime_error("OmniVoice audio-tokenizer encoder request exceeds prepared capacity");
        }
        std::vector<float> acoustic_padded(static_cast<size_t>(acoustic_sample_capacity_), 0.0F);
        std::copy(audio.acoustic_samples_24k.begin(), audio.acoustic_samples_24k.end(), acoustic_padded.begin());
        core::write_tensor_f32(acoustic_input_, acoustic_padded);
        std::vector<float> semantic_padded(static_cast<size_t>(semantic_sample_capacity_), 0.0F);
        std::copy(audio.semantic_samples_16k_padded.begin(), audio.semantic_samples_16k_padded.end(), semantic_padded.begin());
        core::write_tensor_f32(semantic_input_, semantic_padded);
        std::vector<int32_t> downsample(static_cast<size_t>(frame_capacity_), 0);
        for (int64_t i = 0; i < actual_frames; ++i) {
            downsample[static_cast<size_t>(i)] = static_cast<int32_t>(i * semantic_downsample_factor_);
        }
        core::write_tensor_i32(downsample_indices_, downsample);
        tensor_writer_.flush();
        core::set_backend_threads(backend_, compute_threads_);
        const ggml_status status = engine::core::compute_backend_graph(backend_, graph_);
        ggml_backend_synchronize(backend_);
        if (status != GGML_STATUS_SUCCESS) {
            throw std::runtime_error("OmniVoice audio-tokenizer encoder graph compute failed");
        }
        OmniVoiceAudioTokens tokens = {};
        tokens.frames = actual_frames;
        tokens.codebooks = static_cast<int64_t>(code_outputs_.size());
        tokens.reference_rms = audio.reference_rms;
        tokens.token_ids.assign(static_cast<size_t>(actual_frames * tokens.codebooks), 0);
        for (size_t codebook = 0; codebook < code_outputs_.size(); ++codebook) {
            std::vector<int32_t> values(static_cast<size_t>(frame_capacity_), 0);
            ggml_backend_tensor_get(
                code_outputs_[codebook],
                values.data(),
                0,
                values.size() * sizeof(int32_t));
            for (int64_t frame = 0; frame < actual_frames; ++frame) {
                tokens.token_ids[static_cast<size_t>(frame * tokens.codebooks + static_cast<int64_t>(codebook))] =
                    values[static_cast<size_t>(frame)];
            }
        }
        return tokens;
    }

    int64_t frame_capacity() const noexcept { return frame_capacity_; }
    int64_t acoustic_sample_capacity() const noexcept { return acoustic_sample_capacity_; }