FunASR-Nano

Audio (16kHz)
    │
    ▼
┌─────────────────────┐
│   Mel Spectrogram   │  80 bins, 25ms window, 10ms hop
└─────────┬───────────┘
          │
          ▼
┌─────────────────────┐
│   Whisper Encoder   │  Frozen, extracts audio features
└─────────┬───────────┘
          │
          ▼
┌─────────────────────┐
│   Audio Adaptor     │  Linear projection to LLM dim
└─────────┬───────────┘
          │
          ▼
┌─────────────────────┐
│      Qwen LLM       │  Causal language model
└─────────┬───────────┘
          │
          ▼
      Text Output

# Transcribe with default model
cargo run --release --example transcribe -- ./audio.wav

# Specify model directory
cargo run --release --example transcribe -- /path/to/model ./audio.wav

# Benchmark performance (10 iterations)
cargo run --release --example benchmark -- /path/to/model ./audio.wav 10

use funasr_nano_mlx::{FunASRNano, default_model_path};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load model from default path
    let mut model = FunASRNano::load(default_model_path())?;
    
    // Or load from custom path
    let mut model = FunASRNano::load("/path/to/model")?;

    // Transcribe audio file
    let text = model.transcribe("audio.wav")?;
    println!("Transcription: {}", text);

    Ok(())
}

use funasr_nano_mlx::{FunASRNano, default_model_path};

// Load from default path (~/.OminiX/models/funasr-nano)
let mut model = FunASRNano::load(default_model_path())?;

// Load from custom path
let mut model = FunASRNano::load("/path/to/Fun-ASR-Nano-2512")?;

// Transcribe from file path
let text = model.transcribe("audio.wav")?;

// Transcribe from PathBuf
use std::path::PathBuf;
let audio_path = PathBuf::from("audio.wav");
let text = model.transcribe(&audio_path)?;

# Set custom model path
export FUNASR_NANO_MODEL_DIR=/path/to/model

# Set language (for SenseVoice variant, if applicable)
export ASR_NANO_LANGUAGE=auto  # Options: zh, en, ja, ko, auto

# Use in application
cargo run --release --example transcribe -- audio.wav

use funasr_nano_mlx::{FunASRNano, default_model_path};
use std::time::Instant;

fn main() {
    let args: Vec<String> = std::env::args().collect();

    // Parse arguments: [model_dir] <audio_path>
    let (model_dir, audio_path) = match args.len() {
        1 => {
            let model = default_model_path();
            let audio = model.join("example/zh.wav");
            (model, audio)
        }
        2 => {
            (default_model_path(), std::path::PathBuf::from(&args[1]))
        }
        _ => {
            (std::path::PathBuf::from(&args[1]), 
             std::path::PathBuf::from(&args[2]))
        }
    };

    println!("Loading model from {}...", model_dir.display());
    let start = Instant::now();
    let mut model = FunASRNano::load(&model_dir)
        .expect("Failed to load model");
    println!("Model loaded in {:.2}s\n", start.elapsed().as_secs_f32());

    println!("Transcribing {}...", audio_path.display());
    let start = Instant::now();
    match model.transcribe(&audio_path) {
        Ok(text) => {
            let elapsed = start.elapsed().as_secs_f32();
            println!("\nTranscription ({:.2}s):", elapsed);
            println!("{}", text);
        }
        Err(e) => {
            eprintln!("Transcription failed: {}", e);
            std::process::exit(1);
        }
    }
}

use funasr_nano_mlx::{FunASRNano, default_model_path, audio};
use std::time::Instant;

let mut model = FunASRNano::load(default_model_path())?;

// Load audio to get duration
let (samples, sample_rate) = audio::load_wav("audio.wav")?;
let duration_secs = samples.len() as f32 / sample_rate as f32;

// Warmup
let _result = model.transcribe("audio.wav")?;

// Benchmark
let iterations = 10;
let mut times = Vec::new();

for _ in 0..iterations {
    let start = Instant::now();
    let _result = model.transcribe("audio.wav")?;
    let elapsed = start.elapsed().as_millis() as f64;
    times.push(elapsed);
}

// Calculate statistics
times.sort_by(|a, b| a.partial_cmp(b).unwrap());
let mean = times.iter().sum::<f64>() / times.len() as f64;
let rtf_mean = (mean / 1000.0) / duration_secs as f64;

println!("Mean latency: {:.1} ms", mean);
println!("Mean RTF: {:.4}x ({:.1}x real-time)", rtf_mean, 1.0 / rtf_mean);

funasr-nano-mlx/
├── src/
│   ├── lib.rs              # Public API
│   ├── audio.rs            # Audio loading & mel spectrogram
│   ├── whisper_encoder.rs  # Whisper-based audio encoder
│   ├── adaptor.rs          # Audio-to-LLM adaptor
│   ├── qwen.rs             # Qwen LLM (from qwen3-mlx)
│   ├── model.rs            # Combined FunASRNano model
│   └── error.rs            # Error types
├── examples/
│   ├── transcribe.rs       # Basic transcription
│   └── benchmark.rs        # Performance benchmarking
└── Cargo.toml

// Free memory between transcriptions
drop(model);
let model = FunASRNano::load(model_path)?;