extract-speech 0.9.1

Voice activity detection inference for Silero, PulseVAD, PyAnnote, FSMN, TEN VAD, and MarbleNet
Documentation
mod args;
mod download;
mod output;
mod processing;

use anyhow::{Context, Result};
use clap::Parser;
use ort::ep::{CoreML, ExecutionProviderDispatch, TensorRT, CPU, CUDA};
use tracing_subscriber::EnvFilter;

use args::{Args, Command, ModelInfo, Runtime};
use processing::{process_folder, process_single_file};

pub(crate) fn run() -> Result<()> {
    let args = Args::parse();
    init_logging(args.debug)?;

    if let Some(Command::Download(download_args)) = &args.command {
        return download::download(download_args);
    }

    if let Some(info) = args.print_model_info {
        return print_model_info(args.model_path()?, info);
    }
    args.validate()?;

    let execution_providers = execution_providers(&args);
    if args.runtime == Runtime::Onnxruntime {
        let dylib_path = args
            .dylib_path
            .as_deref()
            .context("--dylib-path is required for ONNX Runtime")?;
        extract_speech::init_onnx_runtime(dylib_path, execution_providers.clone())?;
    }

    if let Some(process_audio_path) = &args.process_audio {
        process_single_file(&args, process_audio_path, &execution_providers)
    } else if let Some(process_folder_path) = &args.process_folder {
        process_folder(&args, process_folder_path, &execution_providers)
    } else {
        unreachable!("validated input source")
    }
}

fn init_logging(debug: bool) -> Result<()> {
    let default_filter = if debug { "debug" } else { "info" };
    let filter =
        EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(default_filter));
    tracing_subscriber::fmt()
        .with_env_filter(filter)
        .try_init()
        .map_err(|error| anyhow::anyhow!("failed to initialize logging: {error}"))
}

fn execution_providers(args: &Args) -> Vec<ExecutionProviderDispatch> {
    let mut providers = vec![CPU::default().build()];
    if args.cuda {
        providers.insert(0, CUDA::default().build());
    }
    if args.coreml {
        providers.insert(0, CoreML::default().build());
    }
    if args.trt {
        providers.insert(0, TensorRT::default().build());
    }
    providers
}

fn print_model_info(model_path: &std::path::Path, info: ModelInfo) -> Result<()> {
    let model = candle_onnx::read_file(model_path)?;
    let graph = model
        .graph
        .as_ref()
        .context("ONNX model contains no graph")?;
    match info {
        ModelInfo::Graph => println!("{model:#?}"),
        ModelInfo::Nodes => {
            for node in &graph.node {
                println!("{node:#?}");
            }
        }
        ModelInfo::IO => {
            for input in &graph.input {
                println!("input: {input:#?}");
            }
            for output in &graph.output {
                println!("output: {output:#?}");
            }
        }
    }
    Ok(())
}