import io import os import threading import time from typing import Optional import numpy as np import soundfile as sf import torch import torchaudio from huggingface_hub import login as hf_login from loguru import logger from snac import SNAC from transformers import AutoModelForCausalLM, AutoTokenizer from app.speaker_map import recommended_speed TOKENISER_LENGTH = 128256 END_OF_SPEECH_ID = TOKENISER_LENGTH + 2 PAD_TOKEN_ID = TOKENISER_LENGTH + 7 AUDIO_START_ID = TOKENISER_LENGTH + 10 SAMPLE_RATE = 24000 DEFAULTS = { "temperature": float(os.getenv("TTS_TEMPERATURE", "0.4")), "top_p": float(os.getenv("TTS_TOP_P", "0.9")), "repetition_penalty": float(os.getenv("TTS_REPETITION_PENALTY", "1.05")), "max_seq_length": int(os.getenv("TTS_MAX_SEQ_LENGTH", "2048")), "max_words": int(os.getenv("TTS_MAX_WORDS", "50")), "denoise": os.getenv("TTS_DENOISE", "false").lower() == "true", } class TTSRuntime: def __init__(self) -> None: self._model = None self._tokenizer = None self._snac = None self._df_model = None self._df_state = None self._device = "cuda" if torch.cuda.is_available() else "cpu" self._loaded = False self._lock = threading.Lock() @property def is_ready(self) -> bool: return self._loaded @staticmethod def _resolve_hf_token(cli_token: Optional[str]) -> Optional[str]: if cli_token: return cli_token return ( os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_TOKEN") or os.getenv("HUGGING_FACE_HUB_TOKEN") ) def load(self, model_name: Optional[str] = None, hf_token: Optional[str] = None) -> None: with self._lock: if self._loaded: return # Some environments set HF fast transfer globally without # installing hf_transfer, which breaks all downloads. os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" model_name = model_name or os.getenv("MODEL_NAME", "Mevearth2/Quantized-Merged-TTS") token = self._resolve_hf_token(hf_token) if token: try: hf_login(token=token, add_to_git_credential=False) logger.info("HF auth success") except Exception as exc: logger.warning(f"HF login warning: {exc}") logger.info(f"Loading tokenizer/model from {model_name}") self._tokenizer = AutoTokenizer.from_pretrained(model_name, token=token) self._model = AutoModelForCausalLM.from_pretrained( model_name, token=token, torch_dtype=torch.float16 if self._device == "cuda" else torch.float32, ) self._model.to(self._device) self._model.eval() pad_token = self._tokenizer.decode([PAD_TOKEN_ID]) self._tokenizer.pad_token = pad_token self._tokenizer.padding_side = "left" try: from unsloth import FastLanguageModel FastLanguageModel.for_inference(self._model) logger.info("Unsloth inference enabled") except Exception: logger.info("Unsloth not enabled") logger.info("Loading SNAC decoder") self._snac = SNAC.from_pretrained("hubertsiuzdak/snac_24khz") if DEFAULTS["denoise"]: try: from df.enhance import init_df self._df_model, self._df_state, _ = init_df() logger.info("DeepFilter initialized") except Exception as exc: logger.warning(f"DeepFilter unavailable: {exc}") self._loaded = True @staticmethod def _build_prompt(utterance: str, language: str, user_id: str) -> str: return ( "<|begin_of_text|>" f"{language}{user_id}: {utterance}" "<|eot_id|>" ) @staticmethod def _extract_audio_ids(output_ids: torch.Tensor) -> list[int]: raw_audio_ids = [tok.item() for tok in output_ids if tok.item() >= AUDIO_START_ID] clean = [] full_groups = len(raw_audio_ids) // 7 for i in range(full_groups): base = i * 7 for j in range(7): clean.append(raw_audio_ids[base + j] - AUDIO_START_ID) return clean @staticmethod def _snac_tokens_to_codebooks(clean_audio_ids: list[int]): codes = [[], [], []] full_groups = len(clean_audio_ids) // 7 for i in range(full_groups): b = i * 7 codes[0].append(clean_audio_ids[b + 0]) codes[1].append(clean_audio_ids[b + 1] - 4096) codes[2].append(clean_audio_ids[b + 2] - (2 * 4096)) codes[2].append(clean_audio_ids[b + 3] - (3 * 4096)) codes[1].append(clean_audio_ids[b + 4] - (4 * 4096)) codes[2].append(clean_audio_ids[b + 5] - (5 * 4096)) codes[2].append(clean_audio_ids[b + 6] - (6 * 4096)) if len(codes[0]) == 0 or len(codes[1]) == 0 or len(codes[2]) == 0: return None return [ torch.tensor(codes[0]).unsqueeze(0), torch.tensor(codes[1]).unsqueeze(0), torch.tensor(codes[2]).unsqueeze(0), ] @staticmethod def _apply_speed(audio: np.ndarray, speed: float) -> np.ndarray: if abs(speed - 1.0) <= 1e-4: return audio # Prefer Sox tempo when available; some runtime builds omit sox_effects. if hasattr(torchaudio, "sox_effects") and hasattr(torchaudio.sox_effects, "apply_effects_tensor"): audio_t = torch.from_numpy(audio).unsqueeze(0) out_t, _ = torchaudio.sox_effects.apply_effects_tensor( audio_t, SAMPLE_RATE, effects=[["tempo", f"{speed}"]], ) return out_t.squeeze(0).cpu().numpy() # Fallback: lightweight time-stretch via interpolation. # This keeps service functional even without Sox bindings. in_len = int(audio.shape[0]) out_len = max(1, int(round(in_len / speed))) x_old = np.linspace(0.0, 1.0, num=in_len, dtype=np.float64) x_new = np.linspace(0.0, 1.0, num=out_len, dtype=np.float64) stretched = np.interp(x_new, x_old, audio.astype(np.float64)) return stretched.astype(np.float32) def _apply_denoise(self, audio: np.ndarray) -> np.ndarray: if self._df_model is None or self._df_state is None: return audio try: import librosa from df.enhance import enhance audio_48k = librosa.resample(audio, orig_sr=SAMPLE_RATE, target_sr=48000) audio_48k_t = torch.from_numpy(audio_48k).unsqueeze(0) denoised = enhance(self._df_model, self._df_state, audio_48k_t) denoised_np = denoised.squeeze(0).cpu().numpy() return librosa.resample(denoised_np, orig_sr=48000, target_sr=SAMPLE_RATE) except Exception as exc: logger.warning(f"Denoise failed: {exc}") return audio def synthesize_wav_bytes(self, utterance: str, language: str, user_id: str) -> tuple[bytes, int]: if not self._loaded: raise RuntimeError("Runtime is not loaded") start = time.perf_counter() safe_utterance = " ".join(utterance.split()[: DEFAULTS["max_words"]]) prompt = self._build_prompt(safe_utterance, language, user_id) inputs = self._tokenizer(prompt, add_special_tokens=False, return_tensors="pt") input_ids = inputs.input_ids.to(self._device) attention_mask = inputs.attention_mask.to(self._device) max_new_tokens = max(32, DEFAULTS["max_seq_length"] - input_ids.shape[1]) with torch.inference_mode(): output = self._model.generate( input_ids=input_ids, attention_mask=attention_mask, max_new_tokens=max_new_tokens, do_sample=True, temperature=DEFAULTS["temperature"], top_p=DEFAULTS["top_p"], repetition_penalty=DEFAULTS["repetition_penalty"], eos_token_id=END_OF_SPEECH_ID, ) clean_audio_ids = self._extract_audio_ids(output[0]) if not clean_audio_ids: raise RuntimeError("No audio token IDs generated") codes = self._snac_tokens_to_codebooks(clean_audio_ids) if codes is None: raise RuntimeError("Insufficient audio token IDs for SNAC decode") with torch.inference_mode(): audio = self._snac.decode(codes) audio_np = audio.detach().squeeze().cpu().numpy().astype(np.float32) audio_np = self._apply_speed(audio_np, recommended_speed(language, str(user_id))) audio_np = self._apply_denoise(audio_np) wav_buf = io.BytesIO() sf.write(wav_buf, audio_np, SAMPLE_RATE, format="WAV") wav_bytes = wav_buf.getvalue() duration_ms = int((time.perf_counter() - start) * 1000) return wav_bytes, duration_ms