A standalone, well-documented CTC forced alignment function that converts emission log-probabilities and target sequences into frame-level alignments. It handles batched inputs with variable lengths, ignores a specified ignore_id by substituting blank, and uses dynamic programming with backpointers. The implementation is generic (only depends on PyTorch) and can be extracted into any CTC-based ASR project without modification.

A minimal, single-function module that resolves the SENSEVOICE_DEVICE environment variable to a torch-compatible device string ('cuda:0' or 'cpu'), handling the 'auto' case by checking torch.cuda.is_available(). The logic is clean, fully testable, and easily portable to any AI inference application that needs to normalize user-specified device preferences.

A self-contained SER evaluation script that reads a JSONL manifest of audio paths and canonical emotion labels, runs SenseVoice inference, extracts raw emotion tags before post-processing, and computes weighted accuracy (WA) and unweighted accuracy (UA) with a confusion matrix. It includes label normalization (e.g., 'fear' → 'fearful') and strict validation. The script is parameterized by model/device, outputs structured JSON results, and serves as a reusable evaluation harness for any emotion recognition model following the same protocol.

A single-header C++ implementation of FSMN-VAD (Voice Activity Detection) using ggml for the neural network and a faithful copy of the E2EVadModel state machine from the reference PyTorch implementation. It provides the `funasr_vad_segments()` function that takes a GGUF-format VAD model path and a 16k mono float waveform, and returns speech segments as `[start_ms, end_ms]` pairs. The front-end (mel filterbank, LFR, CMVN) and the FSMN encoder are validated bit-exact against PyTorch, and the state machine matches the reference within 10 ms. This is a high-quality, self-contained component that could be reused in any C++ audio pipeline needing real-time VAD.

A complete C++ inference binary for SenseVoiceSmall using the ggml runtime. It loads a GGUF-format model (SAN-M encoder + CTC head + query embeddings), computes a kaldi-compatible 80-channel mel filterbank with LFR (7/6), prepends the four control tokens, runs the 70-layer encoder through ggml, and performs greedy CTC decoding with blank collapse. The output is either token IDs or, if the GGUF contains an embedded SentencePiece vocabulary, detokenized text (with optional meta-tag removal). The implementation is self-contained (only depends on ggml and miniaudio via the common headers) and validated to match the PyTorch reference exactly. This is the core edge-deployment component of the llama.cpp runtime.

An OpenAI-compatible STT server that exposes REST (`/v1/audio/transcriptions`) and realtime WebSocket (`/v1/realtime?intent=transcription`) endpoints backed by the SenseVoice ggml engine. It includes built-in FSMN-VAD (via `funasr_vad.h`) for sentence end-pointing, supports all OpenAI response formats (json, text, verbose_json, srt, vtt, SSE stream), and implements a streaming VAD-based protocol with incremental partial transcripts. The server is self-contained (one C++ binary, no Python), handles connection limits, malformed input, and audio duration caps, and is validated against frozen transcripts. The architecture cleanly separates the engine (duplicated from the CLI) from transport (httplib).

A reference script for transcribing hour-scale audio without a VAD model, using bounded overlapping windows and lossless chunk output. It streams PCM audio via ffmpeg, iterates over fixed-duration windows with configurable overlap, runs SenseVoice on each chunk, and merges transcripts by removing only exact case-insensitive boundary overlap. The `merge_transcripts` function and the overlapping window iterator are self-contained and could be extracted into any ASR pipeline that needs to handle long audio with limited GPU memory.