"""FastAPI server for Kani TTS with streaming support""" import binascii import io import os from fastapi import FastAPI, HTTPException from fastapi.middleware.cors import CORSMiddleware from fastapi.responses import StreamingResponse, Response from pydantic import BaseModel, Field from typing import Optional, Literal import numpy as np from scipy.io.wavfile import write as wav_write import base64 import json import torch from audio import LLMAudioPlayer, StreamingAudioWriter from generation.vllm_generator import VLLMTTSGenerator from config import ( CHUNK_SIZE, LOOKBACK_FRAMES, TEMPERATURE, TOP_P, MAX_TOKENS, LONG_FORM_THRESHOLD_SECONDS, LONG_FORM_SILENCE_DURATION, LONG_FORM_CHUNK_DURATION, REF_AUDIO_SECONDS, GPU_MEMORY_UTILIZATION, MAX_MODEL_LEN, MODEL_NAME, ) from nemo.utils.nemo_logging import Logger nemo_logger = Logger() nemo_logger.remove_stream_handlers() app = FastAPI(title="Kani TTS API", version="1.0.0") # Add CORS middleware to allow client.html to connect app.add_middleware( CORSMiddleware, allow_origins=["*"], # In production, specify your frontend domain allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # Global instances (initialized on startup) generator = None player = None class TTSRequest(BaseModel): text: str temperature: Optional[float] = TEMPERATURE max_tokens: Optional[int] = MAX_TOKENS top_p: Optional[float] = TOP_P chunk_size: Optional[int] = CHUNK_SIZE lookback_frames: Optional[int] = LOOKBACK_FRAMES class OpenAISpeechRequest(BaseModel): """OpenAI-compatible speech request model""" input: str = Field(..., description="Text to convert to speech") model: Literal["tts-1", "tts-1-hd", "gpt-4o-mini-tts"] = Field(default="tts-1", description="TTS model to use") voice: Optional[str] = Field(default=None, description="Deprecated for this ref-audio server") reference_audio_path: Optional[str] = Field(default=None, description="Server-side path to a WAV file used as voice reference") reference_audio_base64: Optional[str] = Field(default=None, description="Base64-encoded WAV bytes used as voice reference") ref_seconds: Optional[float] = Field(default=REF_AUDIO_SECONDS, description="How many seconds to take from the reference audio") response_format: Literal["wav", "pcm"] = Field(default="wav", description="Audio format: wav or pcm") stream_format: Optional[Literal["sse", "audio"]] = Field(default=None, description="Use 'sse' for Server-Sent Events streaming") # Long-form generation parameters enable_long_form: Optional[bool] = Field(default=True, description="Auto-detect and use long-form generation for texts >15s") max_chunk_duration: Optional[float] = Field(default=12.0, description="Max duration per chunk in long-form mode (seconds)") silence_duration: Optional[float] = Field(default=0.2, description="Silence between chunks in long-form mode (seconds)") @app.on_event("startup") async def startup_event(): """Initialize models on startup""" global generator, player print("🚀 Initializing VLLM TTS models...") # Use VLLM for faster inference generator = VLLMTTSGenerator( tensor_parallel_size=1, # Increase for multi-GPU gpu_memory_utilization=GPU_MEMORY_UTILIZATION, max_model_len=MAX_MODEL_LEN, ) # Initialize the async engine during startup to avoid lazy loading on first request await generator.initialize_engine() player = LLMAudioPlayer(generator.tokenizer) print("✅ VLLM TTS models initialized successfully!") @app.get("/health") async def health_check(): """Check if server is ready""" return { "status": "healthy", "tts_initialized": generator is not None and player is not None, "model_path": MODEL_NAME, } def _resolve_reference_tokens(request: OpenAISpeechRequest): if not request.reference_audio_path and not request.reference_audio_base64: raise HTTPException(status_code=400, detail="reference_audio_path or reference_audio_base64 is required") if request.reference_audio_path and request.reference_audio_base64: raise HTTPException(status_code=400, detail="Provide only one of reference_audio_path or reference_audio_base64") try: if request.reference_audio_path: if not os.path.exists(request.reference_audio_path): raise HTTPException(status_code=400, detail=f"Reference audio not found: {request.reference_audio_path}") return player.prepare_reference_audio_tokens( reference_audio_path=request.reference_audio_path, ref_seconds=request.ref_seconds or REF_AUDIO_SECONDS, ) try: reference_audio_bytes = base64.b64decode(request.reference_audio_base64) except (binascii.Error, ValueError) as exc: raise HTTPException(status_code=400, detail=f"Invalid reference_audio_base64: {exc}") from exc return player.prepare_reference_audio_tokens( reference_audio_bytes=reference_audio_bytes, ref_seconds=request.ref_seconds or REF_AUDIO_SECONDS, ) except HTTPException: raise except Exception as exc: raise HTTPException(status_code=400, detail=f"Failed to encode reference audio: {exc}") from exc @app.post("/v1/audio/speech") async def openai_speech(request: OpenAISpeechRequest): """OpenAI-compatible speech generation endpoint Supports both streaming (SSE) and non-streaming modes: - Without stream_format: Returns complete audio file (WAV or PCM) - With stream_format="sse": Returns Server-Sent Events with audio chunks """ if not generator or not player: raise HTTPException(status_code=503, detail="TTS models not initialized") prompt_text = request.input reference_audio_tokens, reference_frames = _resolve_reference_tokens(request) # Streaming mode (SSE) if request.stream_format == "sse": async def sse_generator(): """Generate Server-Sent Events with audio chunks""" import asyncio import queue as thread_queue from generation.chunking import estimate_duration, split_into_sentences chunk_queue = thread_queue.Queue() # Estimate duration to determine if we need long-form generation estimated_duration = estimate_duration(request.input) use_long_form = estimated_duration > LONG_FORM_THRESHOLD_SECONDS # Track token counts for usage reporting input_token_count = 0 output_token_count = 0 if use_long_form: # Long-form streaming: stream each sentence chunk as it's generated print(f"[Server] Using long-form SSE streaming (estimated {estimated_duration:.1f}s)") async def generate_async_long_form(): nonlocal input_token_count, output_token_count try: # Split into chunks chunks = split_into_sentences(request.input, max_duration_seconds=request.max_chunk_duration or LONG_FORM_CHUNK_DURATION) total_chunks = len(chunks) for i, text_chunk in enumerate(chunks): # Custom list wrapper that pushes chunks to queue class ChunkList(list): def append(self, chunk): super().append(chunk) chunk_queue.put(("chunk", chunk)) audio_writer = StreamingAudioWriter( player, output_file=None, chunk_size=CHUNK_SIZE, lookback_frames=LOOKBACK_FRAMES ) audio_writer.audio_chunks = ChunkList() audio_writer.start() result = await generator._generate_async( text_chunk, audio_writer, max_tokens=MAX_TOKENS, reference_audio_tokens=reference_audio_tokens, ) audio_writer.finalize() # Track tokens input_token_count += len(generator.prepare_input(text_chunk, reference_audio_tokens=reference_audio_tokens)) output_token_count += len(result.get('all_token_ids', [])) # Add silence between chunks (except after last chunk) if i < total_chunks - 1: silence_samples = int((request.silence_duration or LONG_FORM_SILENCE_DURATION) * 22050) silence = np.zeros(silence_samples, dtype=np.float32) chunk_queue.put(("chunk", silence)) chunk_queue.put(("done", {"input": input_token_count, "output": output_token_count})) except Exception as e: print(f"Generation error: {e}") import traceback traceback.print_exc() chunk_queue.put(("error", str(e))) gen_task = asyncio.create_task(generate_async_long_form()) else: # Standard streaming for short texts print(f"[Server] Using standard SSE streaming (estimated {estimated_duration:.1f}s)") # Custom list wrapper that pushes chunks to queue class ChunkList(list): def append(self, chunk): super().append(chunk) chunk_queue.put(("chunk", chunk)) audio_writer = StreamingAudioWriter( player, output_file=None, chunk_size=CHUNK_SIZE, lookback_frames=LOOKBACK_FRAMES ) audio_writer.audio_chunks = ChunkList() # Start generation in background task async def generate_async(): nonlocal input_token_count, output_token_count try: audio_writer.start() result = await generator._generate_async( prompt_text, audio_writer, max_tokens=MAX_TOKENS, reference_audio_tokens=reference_audio_tokens, ) audio_writer.finalize() # Extract token counts from result input_token_count = len(generator.prepare_input(prompt_text, reference_audio_tokens=reference_audio_tokens)) output_token_count = len(result.get('all_token_ids', [])) chunk_queue.put(("done", {"input": input_token_count, "output": output_token_count})) except Exception as e: print(f"Generation error: {e}") import traceback traceback.print_exc() chunk_queue.put(("error", str(e))) # Start generation as async task gen_task = asyncio.create_task(generate_async()) # Stream chunks as they arrive try: while True: msg_type, data = await asyncio.get_event_loop().run_in_executor( None, lambda: chunk_queue.get(timeout=30) ) if msg_type == "chunk": # Convert numpy array to int16 PCM pcm_data = (data * 32767).astype(np.int16) # Encode as base64 audio_base64 = base64.b64encode(pcm_data.tobytes()).decode('utf-8') # Send SSE event: speech.audio.delta event_data = { "type": "speech.audio.delta", "audio": audio_base64 } yield f"data: {json.dumps(event_data)}\n\n" elif msg_type == "done": # Send SSE event: speech.audio.done with usage stats token_counts = data event_data = { "type": "speech.audio.done", "usage": { "input_tokens": token_counts["input"], "output_tokens": token_counts["output"], "total_tokens": token_counts["input"] + token_counts["output"] } } yield f"data: {json.dumps(event_data)}\n\n" break elif msg_type == "error": # Send error event error_data = { "type": "error", "error": data } yield f"data: {json.dumps(error_data)}\n\n" break finally: await gen_task return StreamingResponse( sse_generator(), media_type="text/event-stream", headers={ "Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no" } ) # Non-streaming mode (complete audio file) else: try: # Estimate duration to determine if we need long-form generation from generation.chunking import estimate_duration estimated_duration = estimate_duration(request.input) # Use long-form generation for longer texts use_long_form = estimated_duration > 15.0 if use_long_form: print(f"[Server] Using long-form generation (estimated {estimated_duration:.1f}s)") result = await generator.generate_long_form_async( text=request.input, reference_audio_tokens=reference_audio_tokens, player=player, max_chunk_duration=request.max_chunk_duration or LONG_FORM_CHUNK_DURATION, silence_duration=request.silence_duration or LONG_FORM_SILENCE_DURATION, max_tokens=MAX_TOKENS ) full_audio = result['audio'] else: # Standard generation for short texts. Decode the full token # sequence at once to avoid click artifacts from chunk-by-chunk # codec stitching in non-streaming mode. print(f"[Server] Using standard generation (estimated {estimated_duration:.1f}s)") result = await generator._generate_async( prompt_text, audio_writer=None, max_tokens=MAX_TOKENS, reference_audio_tokens=reference_audio_tokens, player=player, ) if not result.get("all_token_ids"): raise HTTPException(status_code=500, detail="No audio generated") full_audio, _ = player.get_waveform(torch.tensor(result["all_token_ids"], dtype=torch.long)) # Return based on response_format if request.response_format == "pcm": # Return raw PCM (int16) pcm_data = (full_audio * 32767).astype(np.int16) return Response( content=pcm_data.tobytes(), media_type="application/octet-stream", headers={ "Content-Type": "application/octet-stream", "X-Sample-Rate": "22050", "X-Channels": "1", "X-Bit-Depth": "16" } ) else: # wav # Convert to WAV bytes wav_buffer = io.BytesIO() wav_write(wav_buffer, 22050, full_audio) wav_buffer.seek(0) return Response( content=wav_buffer.read(), media_type="audio/wav" ) except Exception as e: print(e) raise HTTPException(status_code=500, detail=str(e)) @app.get("/") async def root(): """Root endpoint with API info""" return { "name": "Kani TTS API", "version": "1.0.0", "endpoints": { "/v1/audio/speech": "POST - ref-audio speech generation", "/health": "GET - Health check" } } if __name__ == "__main__": import uvicorn print("🎤 Starting Kani TTS Server...") uvicorn.run(app, host="0.0.0.0", port=8000)