Is sense-voice-cpp-ggml ready to use?

[sxhxliang]

Hello, can sense-voice-cpp-ggml provide an example? I mainly want to use this SenseVoiceGGUF to achieve real-time speech recognition. If it is available, I can migrate stream to rust

[null-define]

sorry for ignoring the issue for a long time. it seems there is an issue in my github notification settings so I didn't see this. you can ref this code:

use std::path::Path;

use log::debug;
use sense_voice_cpp_ggml::*;

use crate::{asr::sense_voice, error::*, device::DeviceType};

#[derive(Debug)]
pub struct SenseVoiceConfig {
    pub model_path: String,
    pub device: DeviceType,
}

pub struct SenseVoice {
    model_path: String,
    ctx: Option<SenseVoiceContext>,
}

fn convert_integer_to_float_audio(samples: &[i16], output: &mut [f64]) -> Result<()> {
    if samples.len() != output.len() {
        return Err(Error::InvalidInput("length not match".into()));
    }

    for (input, output) in samples.iter().zip(output.iter_mut()) {
        *output = *input as f64 / 32768.0;
    }

    Ok(())
}

impl SenseVoice {
    pub fn new(config: SenseVoiceConfig) -> Result<Self> {
        let mut sense_voice = SenseVoice {
            model_path: config.model_path,
            ctx: None,
        };

        sense_voice.load()?;

        Ok(sense_voice)
    }
    pub fn transcribe(&mut self, audio_data: &[u8]) -> Result<String> {
        reset_ctx_state(self.ctx.as_mut().unwrap());
        let param =
            SenseVoiceFullParamsBuilder::new(SenseVoiceDecodingStrategy::SamplingGreedy).build();
        let cursor = std::io::Cursor::new(audio_data);
        let wav_reader = hound::WavReader::new(cursor)
            .map_err(|e| Error::InvalidInput(format!("Failed to read WAV data: {}", e)))?;
        let samples: Vec<i16> = wav_reader
            .into_samples::<i16>()
            .collect::<std::result::Result<_, _>>()
            .map_err(|e| Error::InvalidInput(format!("Failed to read samples: {}", e)))?;
        let mut float_samples = vec![0.0f64; samples.len()];
        convert_integer_to_float_audio(&samples, &mut float_samples)?;
        let n_seg =
            sense_voice::full_parallel(self.ctx.as_mut().unwrap(), param, &float_samples).unwrap();
        if n_seg != 0 {
            return Err(Error::Model("sense-voice decode error".into()));
        }
        debug!("sense_voice n_seg: {}", n_seg);
        let result = full_get_text(self.ctx.as_mut().unwrap(), false)
            .map_err(|e| Error::Model(format!("Failed to get segment: {}", e)))?;
        debug!("sense_voice result: {}", result);
        Ok(result)
    }
    pub fn load(&mut self) -> Result<()> {
        if self.ctx.is_some() {
            return Ok(());
        }
        if !Path::new(&self.model_path).exists() {
            return Err(Error::Model(format!(
                "Model file not found: {}",
                self.model_path
            )));
        }
        self.ctx = Some(
            SenseVoiceContext::new_with_params(
                &self.model_path,
                SenseVoiceContextParameters::default(),
            )
            .map_err(|e| Error::Model(format!("Failed to load model: {}", e)))?,
        );
        Ok(())
    }

    pub fn unload(&mut self) -> Result<()> {
        self.ctx = None;
        Ok(())
    }
}

the code in the project is already for using but might buggy. I planned to release my chatbot code as ref at August but I played delta force a lot last month so this is delayed.