Upload folder using huggingface_hub

LICENSE

@@ -0,0 +1,201 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"Source" shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation
+source, and configuration files.
+
+"Object" shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but
+not limited to compiled object code, generated documentation,
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or
+Object form, made available under the License, as indicated by a
+copyright notice that is included in or attached to the work
+(which shall not include communications that are solely in the
+nature of comments, suggestions or bug reports, but does not
+include comments that are part of a notice similar to the Exemplary
+legal notices set forth below).
+
+"Derivative Works" shall mean any work, whether in Source or Object
+form, that is based upon (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and derivative works thereof.
+
+"Contributor" shall mean Licensor and any individual or Legal Entity
+on behalf of whom a Contribution has been received by Licensor and
+subsequently incorporated within the Work.
+
+"Contribution" shall mean any work of authorship, including
+the original version of the Work and any modifications or additions
+to that Work or Derivative Works thereof, that is intentionally
+submitted to Licensor for inclusion in the Work by the copyright
+owner or by an individual or Legal Entity authorized to submit on
+behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written
+communication sent to the Licensor or its representatives, including
+but not limited to communication on electronic mailing lists,
+source code control systems, and issue tracking systems that are
+managed by, or on behalf of, the Licensor for the purpose of
+discussing and improving the Work, but excluding communication that
+is conspicuously marked or otherwise designated in writing by the
+copyright owner as "Not a Contribution."
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+copyright license to use, reproduce, modify, display, perform,
+sublicense, and distribute the Work and such Derivative Works in
+Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except as stated in this section) patent license to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent claims licensable
+by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s)
+with the Work to which such Contribution(s) was submitted. If You
+institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work
+or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate
+as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You
+meet the following conditions:
+
+(a) You must give any other recipients of the Work or
+Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices
+stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works
+that You distribute, all copyright, patent, trademark, and
+attribution notices from the Source form of the Work,
+excluding those notices that do not pertain to any part of
+the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its
+distribution, then any Derivative Works that You distribute must
+include a readable copy of the attribution notices contained
+within such NOTICE file, excluding those notices that do not
+pertain to any part of the Derivative Works, in at least one
+of the following places: within a NOTICE text file distributed
+as part of the Derivative Works; within the Source form or
+documentation, if provided along with the Derivative Works; or,
+within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents
+of the NOTICE file are for informational purposes only and
+do not modify the License. You may add Your own attribution
+notices within Derivative Works that You distribute, alongside
+or as an addendum to the NOTICE text from the Work, provided
+that such additional attribution notices cannot be construed
+as modifying the License.
+
+You may add Your own copyright notice and may provide additional or
+different license terms and conditions for use, reproduction, or
+distribution of Your Derivative Works as a whole, provided Your use,
+reproduction, and distribution of the Work otherwise complies with
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+any Contribution intentionally submitted for inclusion in the Work
+by You to the Licensor shall be under the terms and conditions of
+this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify
+the terms of any separate license agreement you may have executed
+with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor,
+except as required for reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+agreed to in writing, Licensor provides the Work (and each
+Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied, including, without limitation, any warranties or conditions
+of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any
+risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise,
+unless required by applicable law (such as deliberate and grossly
+negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses), even if such Contributor
+has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Support. You may choose to offer, and to
+charge a fee for, warranty, support, indemnity, or other liability
+obligations and/or rights consistent with this License. However, in
+accepting such obligations, You may act only on Your own behalf and on
+Your sole responsibility, not on behalf of any other Contributor, and
+only if You agree to indemnify, defend, and hold each Contributor
+harmless for any liability incurred by, or claims asserted against,
+such Contributor by reason of your accepting any such warranty or support.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following
+boilerplate notice, with the fields enclosed by brackets "[]"
+replaced with your own identifying information. (Don't include
+the brackets!)  The text should be enclosed in the appropriate
+comment syntax for the file format. We also recommend that a
+file or class name and description of purpose be included on the
+same page as the copyright notice for easier identification within
+third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

README.md

@@ -0,0 +1,68 @@
+# Bulgarian Ref-Audio KaniTTS Server Code
+
+Това repo съдържа само server кода за локално ползване и изтегляне.
+
+То не е Hugging Face Space за хостван inference. Идеята е потребителят да може да го свали и да го пусне на собствена машина с GPU.
+
+## Какво има вътре
+
+- `server.py` — FastAPI endpoint `/v1/audio/speech`
+- `config.py` — конфигурация и model repo id
+- `audio/` — codec decode и reference audio encode логика
+- `generation/` — vLLM prompt/generation логика
+- `render_radio_play.py` — оркестратор за дълги сценарии и радио пиеси
+- `test_rtf.py` — еднократен RTF benchmark
+- `benchmark_rtf_warm.py` — warm benchmark в един процес
+
+## Модел
+
+По подразбиране кодът очаква публикувания модел:
+
+- `beleata74/kani-tts-400m-bg-refaudio5s`
+
+Можеш да override-неш това с env variable:
+
+```bash
+export KANITTS_MODEL_PATH=beleata74/kani-tts-400m-bg-refaudio5s
+```
+
+## Бърз старт
+
+```bash
+git clone https://huggingface.co/datasets/beleata74/kani-tts-bg-refaudio-server-code
+cd kani-tts-bg-refaudio-server-code
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+python server.py
+```
+
+После:
+
+```bash
+curl http://localhost:8000/health
+```
+
+Примерна заявка:
+
+```bash
+curl -X POST http://localhost:8000/v1/audio/speech \
+  -H "Content-Type: application/json" \
+  -d '{
+    "input": "Това е тест на българския ref-audio сървър.",
+    "reference_audio_path": "/path/to/reference.wav",
+    "response_format": "wav"
+  }' \
+  --output speech.wav
+```
+
+## Изисквания
+
+- Linux
+- NVIDIA GPU
+- CUDA-съвместим PyTorch/vLLM setup
+- `ffmpeg`
+
+## Бележка
+
+Има и отделен Hugging Face Space repo за същия код, но това repo е качено специално като downloadable code package.

audio/__init__.py

@@ -0,0 +1,6 @@
+"""Audio processing modules for Kani TTS"""
+
+from .player import LLMAudioPlayer
+from .streaming import StreamingAudioWriter
+
+__all__ = ['LLMAudioPlayer', 'StreamingAudioWriter']

audio/player.py

@@ -0,0 +1,159 @@
+"""Audio player for LLM-generated speech tokens"""
+
+import io
+
+import numpy as np
+import soundfile as sf
+import torch
+from nemo.collections.tts.models import AudioCodecModel
+from scipy.signal import resample_poly
+
+from config import (
+    TOKENIZER_LENGTH, START_OF_TEXT, END_OF_TEXT,
+    START_OF_SPEECH, END_OF_SPEECH, START_OF_HUMAN, END_OF_HUMAN,
+    START_OF_AI, END_OF_AI, PAD_TOKEN, AUDIO_TOKENS_START, CODEBOOK_SIZE,
+    CODEC_MODEL_NAME, NUM_CODEBOOKS, SAMPLE_RATE, REF_AUDIO_SECONDS,
+)
+
+
+class LLMAudioPlayer:
+    def __init__(self, tokenizer) -> None:
+        self.nemo_codec_model = AudioCodecModel\
+                .from_pretrained(CODEC_MODEL_NAME).eval()
+
+        if torch.cuda.is_available():
+            self.device = 'cuda'
+        elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+            self.device = 'mps'
+        else:
+            self.device = 'cpu'
+
+        self.nemo_codec_model.to(self.device)
+
+        # NOTE: torch.compile disabled for codec due to varying input shapes causing recompilations
+        # The codec is called with different frame counts, which triggers too many recompilations
+
+        self.tokenizer = tokenizer
+
+        self.tokenizer_length = TOKENIZER_LENGTH
+        self.start_of_text = START_OF_TEXT
+        self.end_of_text = END_OF_TEXT
+        self.start_of_speech = START_OF_SPEECH
+        self.end_of_speech = END_OF_SPEECH
+        self.start_of_human = START_OF_HUMAN
+        self.end_of_human = END_OF_HUMAN
+        self.start_of_ai = START_OF_AI
+        self.end_of_ai = END_OF_AI
+        self.pad_token = PAD_TOKEN
+        self.audio_tokens_start = AUDIO_TOKENS_START
+        self.codebook_size = CODEBOOK_SIZE
+        self.num_codebooks = NUM_CODEBOOKS
+        self.sample_rate = SAMPLE_RATE
+
+    def output_validation(self, out_ids):
+        start_of_speech_flag = self.start_of_speech in out_ids
+        end_of_speech_flag = self.end_of_speech in out_ids
+        if not (start_of_speech_flag and end_of_speech_flag):
+            raise ValueError('Special speech tokens not exist!')
+
+    def get_nano_codes(self, out_ids):
+        start_a_idx = (out_ids == self.start_of_speech).nonzero(as_tuple=True)[0].item()
+        end_a_idx   = (out_ids == self.end_of_speech).nonzero(as_tuple=True)[0].item()
+        if start_a_idx >= end_a_idx:
+            raise ValueError('Invalid audio codes sequence!')
+
+        audio_codes = out_ids[start_a_idx+1 : end_a_idx]
+        if len(audio_codes) % self.num_codebooks:
+            raise ValueError(f'The length of the sequence must be a multiple of {self.num_codebooks}!')
+        audio_codes = audio_codes.reshape(-1, self.num_codebooks)
+        audio_codes = audio_codes - torch.tensor([self.codebook_size * i for i in range(self.num_codebooks)])
+        audio_codes = audio_codes - self.audio_tokens_start
+        if (audio_codes < 0).sum().item() > 0:
+            raise ValueError('Invalid audio tokens!')
+
+        audio_codes = audio_codes.T.unsqueeze(0)
+        len_ = torch.tensor([audio_codes.shape[-1]])
+        return audio_codes, len_
+
+    def get_text(self, out_ids):
+        try:
+            start_t_idx = (out_ids == self.start_of_text).tolist().index(True)
+            end_t_idx   = (out_ids == self.end_of_text).tolist().index(True)
+            txt_tokens = out_ids[start_t_idx : end_t_idx+1]
+            text = self.tokenizer.decode(txt_tokens, skip_special_tokens=True)
+            return text
+        except ValueError:
+            return None
+
+    def get_waveform(self, out_ids):
+        out_ids = out_ids.flatten()
+        self.output_validation(out_ids)
+        audio_codes, len_ = self.get_nano_codes(out_ids)
+        audio_codes, len_ = audio_codes.to(self.device), len_.to(self.device)
+        with torch.inference_mode():
+            reconstructed_audio, _ = self.nemo_codec_model.decode(tokens=audio_codes, tokens_len=len_)
+            output_audio = reconstructed_audio.cpu().detach().numpy().squeeze()
+
+        text = self.get_text(out_ids)
+        return output_audio, text
+
+    def decode_audio_chunk(self, audio_codes):
+        """Decode a chunk of audio codes (shape: [num_frames, num_codebooks])."""
+        if len(audio_codes) == 0:
+            return None
+
+        # Process audio codes: subtract offsets for each codebook
+        audio_codes = torch.tensor(audio_codes, device=self.device)
+        audio_codes = audio_codes - torch.tensor([self.codebook_size * i for i in range(self.num_codebooks)], device=self.device)
+        audio_codes = audio_codes - self.audio_tokens_start
+
+        if (audio_codes < 0).sum().item() > 0:
+            return None  # Invalid tokens, skip
+
+        # Shape: (1, 4, num_frames) - batch_size=1, num_codebooks=4, num_frames
+        audio_codes = audio_codes.T.unsqueeze(0)
+        len_ = torch.tensor([audio_codes.shape[-1]], device=self.device)
+
+        with torch.inference_mode():
+            reconstructed_audio, _ = self.nemo_codec_model.decode(tokens=audio_codes, tokens_len=len_)
+            output_audio = reconstructed_audio.cpu().detach().numpy().squeeze()
+
+        return output_audio
+
+    def _normalize_reference_audio(self, audio, sample_rate, ref_seconds):
+        if audio.ndim == 2:
+            audio = audio.mean(axis=1)
+        if sample_rate != self.sample_rate:
+            audio = resample_poly(audio, self.sample_rate, sample_rate)
+        max_samples = int(round(self.sample_rate * ref_seconds))
+        return np.asarray(audio[:max_samples], dtype=np.float32)
+
+    def _flatten_reference_codes(self, ref_tokens):
+        codes = ref_tokens[0].detach().cpu().numpy().T
+        offsets = np.array([self.codebook_size * i for i in range(self.num_codebooks)])
+        codes = codes + offsets
+
+        if len(codes) > 1:
+            frame_changed = np.any(codes[1:] != codes[:-1], axis=1)
+            keep = np.insert(frame_changed, 0, True)
+            codes = codes[keep]
+
+        return (codes + self.audio_tokens_start).flatten().tolist()
+
+    def prepare_reference_audio_tokens(self, reference_audio_path=None, reference_audio_bytes=None, ref_seconds=REF_AUDIO_SECONDS):
+        if bool(reference_audio_path) == bool(reference_audio_bytes):
+            raise ValueError("Provide exactly one of reference_audio_path or reference_audio_bytes")
+
+        if reference_audio_path:
+            audio, sample_rate = sf.read(reference_audio_path)
+        else:
+            audio, sample_rate = sf.read(io.BytesIO(reference_audio_bytes))
+
+        audio = self._normalize_reference_audio(audio, sample_rate, ref_seconds)
+        audio_tensor = torch.tensor(audio, dtype=torch.float32, device=self.device).unsqueeze(0)
+        audio_len = torch.tensor([audio_tensor.shape[1]], dtype=torch.long, device=self.device)
+
+        with torch.inference_mode():
+            ref_tokens, ref_tokens_len = self.nemo_codec_model.encode(audio=audio_tensor, audio_len=audio_len)
+
+        return self._flatten_reference_codes(ref_tokens), ref_tokens_len.tolist()

audio/streaming.py

@@ -0,0 +1,152 @@
+"""Streaming audio writer with sliding window decoder"""
+
+import threading
+import queue
+import numpy as np
+from scipy.io.wavfile import write
+
+from config import SAMPLE_RATE, CHUNK_SIZE, LOOKBACK_FRAMES
+
+
+class StreamingAudioWriter:
+    def __init__(self, player, output_file, sample_rate=SAMPLE_RATE,
+                 chunk_size=CHUNK_SIZE, lookback_frames=LOOKBACK_FRAMES):
+        """
+        Sliding window decoder with lookback context.
+
+        Args:
+            player: LLMAudioPlayer instance
+            output_file: Output WAV file path
+            sample_rate: Audio sample rate (22050 Hz for nanocodec)
+            chunk_size: Number of NEW frames to output per iteration
+            lookback_frames: Number of frames to include from previous context for continuity
+        """
+        self.player = player
+        self.output_file = output_file
+        self.sample_rate = sample_rate
+        self.chunk_size = chunk_size
+        self.lookback_frames = lookback_frames
+        self.token_queue = queue.Queue()
+        self.audio_chunks = []
+        self.running = True
+        self.inside_speech = False
+        self.audio_token_buffer = []
+        self.all_tokens = []  # Store all audio tokens for sliding window decoding
+        self.frames_decoded = 0  # Track how many frames we've already output
+
+    def decoder_worker(self):
+        """Background thread that decodes audio chunks as they arrive"""
+        speech_ended = False
+
+        while self.running or not self.token_queue.empty():
+            try:
+                token_id = self.token_queue.get(timeout=0.1)
+
+                # Check for start/end of speech markers
+                if token_id == self.player.start_of_speech:
+                    self.inside_speech = True
+                    speech_ended = False
+                    self.audio_token_buffer = []
+                    continue
+
+                if token_id == self.player.end_of_speech:
+
+                    # Decode any remaining frames with sliding window
+                    total_frames = len(self.all_tokens) // 4
+                    remaining_frames = total_frames - self.frames_decoded
+
+                    if remaining_frames >= 1:
+                        # Decode from lookback point to end
+                        start_frame = max(0, self.frames_decoded - self.lookback_frames)
+                        start_token = start_frame * 4
+
+                        tokens_to_decode = self.all_tokens[start_token:]
+                        num_frames = len(tokens_to_decode) // 4
+
+                        if num_frames > 0:
+                            codes = np.array(tokens_to_decode[:num_frames * 4]).reshape(-1, 4)
+                            audio_chunk = self.player.decode_audio_chunk(codes)
+
+                            if audio_chunk is not None:
+                                samples_per_frame = len(audio_chunk) // num_frames
+
+                                # Skip lookback portion, only save new frames
+                                lookback_skip = min(self.frames_decoded, self.lookback_frames)
+                                skip_samples = lookback_skip * samples_per_frame
+                                new_audio = audio_chunk[skip_samples:]
+
+                                self.audio_chunks.append(new_audio)
+
+                    self.inside_speech = False
+                    speech_ended = True
+                    self.audio_token_buffer = []
+                    continue
+
+                # Accumulate audio tokens (only if speech hasn't ended)
+                if self.inside_speech and not speech_ended:
+                    self.audio_token_buffer.append(token_id)
+                    self.all_tokens.append(token_id)  # Keep all tokens for sliding window
+
+                    # Decode when we have enough NEW frames to process
+                    total_frames = len(self.all_tokens) // 4
+                    new_frames = total_frames - self.frames_decoded
+
+                    if new_frames >= self.chunk_size:
+                        # Calculate sliding window: include lookback_frames from previous context
+                        start_frame = max(0, self.frames_decoded - self.lookback_frames)
+                        start_token = start_frame * 4
+
+                        # Decode from start_frame to current end
+                        tokens_to_decode = self.all_tokens[start_token:]
+                        num_frames = len(tokens_to_decode) // 4
+
+                        codes = np.array(tokens_to_decode[:num_frames * 4]).reshape(-1, 4)
+                        audio_chunk = self.player.decode_audio_chunk(codes)
+
+                        if audio_chunk is not None:
+                            samples_per_frame = len(audio_chunk) // num_frames
+
+                            # Skip the lookback portion - only save the NEW frames
+                            lookback_skip = min(self.frames_decoded, self.lookback_frames)
+                            skip_samples = lookback_skip * samples_per_frame
+
+                            # Extract only the new chunk_size frames worth of audio
+                            new_samples = self.chunk_size * samples_per_frame
+                            new_audio = audio_chunk[skip_samples:skip_samples + new_samples]
+
+                            self.audio_chunks.append(new_audio)
+                            self.frames_decoded += self.chunk_size
+
+                        # Clear buffer (we've stored everything in all_tokens)
+                        self.audio_token_buffer = []
+
+            except queue.Empty:
+                continue
+
+    def add_token(self, token_id):
+        """Add a token to the processing queue"""
+        self.token_queue.put(token_id)
+
+    def finalize(self):
+        """Stop the decoder thread and write final audio file"""
+        self.running = False
+        self.decoder_thread.join()
+
+        if self.audio_chunks:
+            # Concatenate all audio chunks
+            full_audio = np.concatenate(self.audio_chunks)
+
+            # Calculate actual audio duration
+            actual_duration = len(full_audio) / self.sample_rate
+
+            # Only write to file if output_file is specified
+            if self.output_file:
+                write(self.output_file, self.sample_rate, full_audio)
+
+            return full_audio
+        return None
+
+    def start(self):
+        """Start the decoder thread"""
+        self.decoder_thread = threading.Thread(target=self.decoder_worker)
+        self.decoder_thread.start()

benchmark_rtf_warm.py

@@ -0,0 +1,60 @@
+"""Warm RTF benchmark for the Bulgarian ref-audio vLLM setup."""
+
+import asyncio
+import os
+
+from audio import LLMAudioPlayer, StreamingAudioWriter
+from config import CHUNK_SIZE, LOOKBACK_FRAMES, REF_AUDIO_SECONDS, GPU_MEMORY_UTILIZATION, MAX_MODEL_LEN
+from generation.vllm_generator import VLLMTTSGenerator
+
+
+PROMPTS = [
+    "Това е кратък тест за real-time factor на ref-audio сървъра.",
+    "Рано сутрин реката е спокойна, а гласът трябва да звучи ясно, плавно и естествено.",
+]
+
+
+async def run_once(generator, player, prompt, reference_audio_tokens):
+    audio_writer = StreamingAudioWriter(
+        player,
+        output_file=None,
+        chunk_size=CHUNK_SIZE,
+        lookback_frames=LOOKBACK_FRAMES,
+    )
+    audio_writer.start()
+    result = await generator._generate_async(
+        prompt,
+        audio_writer,
+        reference_audio_tokens=reference_audio_tokens,
+    )
+    audio_writer.finalize()
+    return result
+
+
+async def main():
+    generator = VLLMTTSGenerator(
+        tensor_parallel_size=1,
+        gpu_memory_utilization=GPU_MEMORY_UTILIZATION,
+        max_model_len=MAX_MODEL_LEN,
+    )
+    await generator.initialize_engine()
+
+    player = LLMAudioPlayer(generator.tokenizer)
+    reference_audio_path = os.environ.get("KANITTS_TEST_REF_AUDIO", "/home/nasko/besttts/REF/woman.wav")
+    reference_audio_tokens, reference_frames = player.prepare_reference_audio_tokens(
+        reference_audio_path=reference_audio_path,
+        ref_seconds=REF_AUDIO_SECONDS,
+    )
+
+    print(f"Reference frames: {reference_frames}")
+    for index, prompt in enumerate(PROMPTS, start=1):
+        result = await run_once(generator, player, prompt, reference_audio_tokens)
+        print(
+            f"RUN {index}: tokens={len(result['all_token_ids'])} "
+            f"dur={result['audio_duration']:.2f}s gen={result['generation_time']:.2f}s "
+            f"RTF={result['rtf']:.3f}"
+        )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

config.py

@@ -0,0 +1,53 @@
+"""Configuration and constants for ref-audio Kani TTS serving."""
+
+import os
+from pathlib import Path
+
+# Tokenizer configuration
+TOKENIZER_LENGTH = 64400
+NUM_CODEBOOKS = 4
+
+# Special tokens
+START_OF_TEXT = 1
+END_OF_TEXT = 2
+START_OF_SPEECH = TOKENIZER_LENGTH + 1
+END_OF_SPEECH = TOKENIZER_LENGTH + 2
+START_OF_HUMAN = TOKENIZER_LENGTH + 3
+END_OF_HUMAN = TOKENIZER_LENGTH + 4
+START_OF_AI = TOKENIZER_LENGTH + 5
+END_OF_AI = TOKENIZER_LENGTH + 6
+PAD_TOKEN = TOKENIZER_LENGTH + 7
+AUDIO_TOKENS_START = TOKENIZER_LENGTH + 10
+
+# Audio configuration
+CODEBOOK_SIZE = 4032
+SAMPLE_RATE = 22050
+REF_AUDIO_SECONDS = 5.0
+
+# Streaming configuration
+CHUNK_SIZE = 25  # Number of new frames to output per iteration
+LOOKBACK_FRAMES = 15  # Number of frames to include from previous context
+
+# Generation configuration
+TEMPERATURE = 0.6
+TOP_P = 0.95
+REPETITION_PENALTY = 1.1
+REPETITION_CONTEXT_SIZE = 20
+MAX_TOKENS = 1200
+
+# Long-form generation configuration
+LONG_FORM_THRESHOLD_SECONDS = 15.0  # Auto-enable chunking for texts estimated >15s
+LONG_FORM_CHUNK_DURATION = 12.0     # Target duration per chunk (stay within 5-15s training distribution)
+LONG_FORM_SILENCE_DURATION = 0.2    # Silence between chunks in seconds
+
+
+# Model paths
+_ROOT = Path(__file__).resolve().parent
+TOKENIZER_NAME = os.environ.get("KANITTS_TOKENIZER_NAME", "nineninesix/kani-tts-400m-0.3-pt")
+MODEL_NAME = os.environ.get(
+    "KANITTS_MODEL_PATH",
+    "beleata74/kani-tts-400m-bg-refaudio5s",
+)
+CODEC_MODEL_NAME = "nvidia/nemo-nano-codec-22khz-0.6kbps-12.5fps"
+GPU_MEMORY_UTILIZATION = float(os.environ.get("KANITTS_GPU_MEMORY_UTILIZATION", "0.5"))
+MAX_MODEL_LEN = int(os.environ.get("KANITTS_MAX_MODEL_LEN", "1536"))

generation/__init__.py

@@ -0,0 +1,6 @@
+"""Text-to-speech generation modules"""
+
+from .vllm_generator import VLLMTTSGenerator
+from .chunking import split_into_sentences, estimate_duration
+
+__all__ = ['VLLMTTSGenerator', 'split_into_sentences', 'estimate_duration']

generation/chunking.py

@@ -0,0 +1,100 @@
+"""Text chunking utilities for long-form speech generation"""
+
+import re
+from typing import List
+
+
+def split_into_sentences(text: str, max_duration_seconds: float = 12.0) -> List[str]:
+    """Split text into sentences suitable for TTS generation
+
+    The chunking strategy ensures each chunk is within the model's training
+    distribution (5-15 seconds of speech) for optimal quality.
+
+    Args:
+        text: Input text to split
+        max_duration_seconds: Maximum target duration per chunk (default 12s)
+
+    Returns:
+        List of text chunks, each representing ~max_duration_seconds of speech
+
+    Notes:
+        - Uses heuristic of ~15 characters per second of speech
+        - Splits on sentence boundaries (., !, ?)
+        - Keeps sentences together when possible
+        - Fallback to word-level splitting for very long sentences
+    """
+    # Heuristic: ~15 characters per second of speech (adjustable based on your model)
+    max_chars = int(max_duration_seconds * 15)
+
+    # Split into sentences using common punctuation
+    # This regex keeps the punctuation with the sentence
+    sentence_pattern = r'([.!?]+[\s\n]+|[.!?]+$)'
+    parts = re.split(sentence_pattern, text)
+
+    # Reconstruct sentences (combine text + punctuation)
+    sentences = []
+    for i in range(0, len(parts) - 1, 2):
+        sentence = parts[i]
+        if i + 1 < len(parts):
+            sentence += parts[i + 1]
+        sentences.append(sentence.strip())
+
+    # Handle last part if no punctuation at end
+    if len(parts) % 2 == 1 and parts[-1].strip():
+        sentences.append(parts[-1].strip())
+
+    # Filter empty sentences
+    sentences = [s for s in sentences if s]
+
+    # Group sentences into chunks
+    chunks = []
+    current_chunk = ""
+
+    for sentence in sentences:
+        # If single sentence exceeds max, split it by words
+        if len(sentence) > max_chars:
+            # Save current chunk if any
+            if current_chunk:
+                chunks.append(current_chunk.strip())
+                current_chunk = ""
+
+            # Split long sentence into word-based chunks
+            words = sentence.split()
+            word_chunk = ""
+            for word in words:
+                if len(word_chunk) + len(word) + 1 <= max_chars:
+                    word_chunk += word + " "
+                else:
+                    chunks.append(word_chunk.strip())
+                    word_chunk = word + " "
+
+            if word_chunk.strip():
+                current_chunk = word_chunk.strip()
+
+        # Check if adding this sentence would exceed max
+        elif len(current_chunk) + len(sentence) + 1 <= max_chars:
+            current_chunk += " " + sentence if current_chunk else sentence
+        else:
+            # Save current chunk and start new one
+            if current_chunk:
+                chunks.append(current_chunk.strip())
+            current_chunk = sentence
+
+    # Add final chunk
+    if current_chunk:
+        chunks.append(current_chunk.strip())
+
+    return chunks
+
+
+def estimate_duration(text: str, chars_per_second: float = 15.0) -> float:
+    """Estimate speech duration for given text
+
+    Args:
+        text: Input text
+        chars_per_second: Average characters spoken per second
+
+    Returns:
+        Estimated duration in seconds
+    """
+    return len(text) / chars_per_second

generation/vllm_generator.py

@@ -0,0 +1,363 @@
+"""VLLM-based text-to-speech generation logic with async streaming"""
+
+import asyncio
+import time
+import torch
+import numpy as np
+from vllm import AsyncEngineArgs, AsyncLLMEngine, SamplingParams
+from transformers import AutoTokenizer
+
+from config import (
+    MODEL_NAME, TOKENIZER_NAME, START_OF_HUMAN, END_OF_TEXT, END_OF_HUMAN, END_OF_AI,
+    START_OF_SPEECH, END_OF_SPEECH, TEMPERATURE, TOP_P, REPETITION_PENALTY,
+    MAX_TOKENS, SAMPLE_RATE
+)
+
+
+class VLLMTTSGenerator:
+    def __init__(self, tensor_parallel_size=1, gpu_memory_utilization=0.9, max_model_len=2048):
+        """Initialize VLLM-based TTS generator with async streaming support
+
+        Args:
+            tensor_parallel_size: Number of GPUs to use for tensor parallelism
+            gpu_memory_utilization: Fraction of GPU memory to use (0.0 to 1.0)
+            max_model_len: Maximum sequence length
+        """
+        print(f"Loading VLLM AsyncLLMEngine model: {MODEL_NAME}")
+
+        # Configure engine arguments
+        engine_args = AsyncEngineArgs(
+            model=MODEL_NAME,
+            tokenizer=TOKENIZER_NAME,
+            tensor_parallel_size=tensor_parallel_size,
+            max_model_len=max_model_len,
+            gpu_memory_utilization=gpu_memory_utilization,
+            enforce_eager=False,  # Allow CUDA graphs (reduces kernel launch overhead)
+            max_num_seqs=1,  # Single sequence for TTS - enables better CUDA graph optimization
+            dtype="bfloat16",  # BF16 for faster inference on RTX 5090
+        )
+
+        # Create async engine
+        self.engine = None  # Will be initialized in async context
+        self.engine_args = engine_args
+
+        self.tokenizer = AutoTokenizer.from_pretrained(TOKENIZER_NAME)
+
+        # Pre-configure sampling parameters
+        self.sampling_params = SamplingParams(
+            temperature=TEMPERATURE,
+            top_p=TOP_P,
+            max_tokens=MAX_TOKENS,
+            repetition_penalty=REPETITION_PENALTY,
+            stop_token_ids=[END_OF_AI],
+        )
+
+    async def initialize_engine(self):
+        """Initialize the async engine - call this during startup to avoid lazy loading"""
+        if self.engine is None:
+            print("Initializing VLLM AsyncLLMEngine...")
+            self.engine = AsyncLLMEngine.from_engine_args(self.engine_args)
+            print("VLLM AsyncLLMEngine initialized and ready!")
+
+    def prepare_input(self, prompt_text, reference_audio_tokens=None):
+        """Build custom input_ids with ref-audio conditioning tokens."""
+        input_ids = self.tokenizer(prompt_text, return_tensors="pt").input_ids
+        reference_audio_tokens = reference_audio_tokens or []
+
+        start_token = torch.tensor([[START_OF_HUMAN]], dtype=torch.int64)
+        ref_tokens = torch.tensor(
+            [[START_OF_SPEECH] + reference_audio_tokens + [END_OF_SPEECH]],
+            dtype=torch.int64,
+        )
+        end_tokens = torch.tensor([[END_OF_TEXT, END_OF_HUMAN]], dtype=torch.int64)
+        modified_input_ids = torch.cat([start_token, ref_tokens, input_ids, end_tokens], dim=1)
+
+        # Convert to list for VLLM
+        return modified_input_ids[0].tolist()
+
+    async def _generate_async(self, prompt, audio_writer, max_tokens=MAX_TOKENS, reference_audio_tokens=None):
+        """Async generator that streams tokens as they are generated
+
+        Args:
+            prompt: Text prompt to convert to speech
+            audio_writer: StreamingAudioWriter instance to receive tokens
+            max_tokens: Maximum number of tokens to generate
+
+        Returns:
+            Dictionary with generation metrics and results
+        """
+        # Initialize engine if needed
+        if self.engine is None:
+            self.engine = AsyncLLMEngine.from_engine_args(self.engine_args)
+
+        # Prepare input_ids with special tokens
+        input_ids = self.prepare_input(prompt, reference_audio_tokens=reference_audio_tokens)
+
+        point_1 = time.time()
+
+        # Override max_tokens if different from default
+        if max_tokens != MAX_TOKENS:
+            sampling_params = SamplingParams(
+                temperature=TEMPERATURE,
+                top_p=TOP_P,
+                max_tokens=max_tokens,
+                repetition_penalty=REPETITION_PENALTY,
+                stop_token_ids=[END_OF_AI],
+            )
+        else:
+            sampling_params = self.sampling_params
+
+        # Generate unique request ID
+        request_id = f"tts-{id(prompt)}-{time.time()}"
+
+        # Stream tokens as they are generated
+        all_token_ids = []
+        audio_token_count = 0
+        inside_speech = False
+
+        # Add request to engine with TokensPrompt
+        results_generator = self.engine.generate(
+            {"prompt_token_ids": input_ids},
+            sampling_params,
+            request_id=request_id
+        )
+
+        async for request_output in results_generator:
+            # Get newly generated tokens
+            new_token_ids = request_output.outputs[0].token_ids
+
+            # Find which tokens are new since last iteration
+            num_new_tokens = len(new_token_ids) - len(all_token_ids)
+            if num_new_tokens > 0:
+                new_tokens = new_token_ids[-num_new_tokens:]
+                all_token_ids.extend(new_tokens)
+
+                # Stream each new token to audio_writer and count audio tokens
+                for token_id in new_tokens:
+                    # print(f"[VLLM] Token {len(all_token_ids)}: {token_id}")
+                    audio_writer.add_token(token_id)
+
+                    # Track audio tokens efficiently during streaming
+                    if token_id == audio_writer.player.start_of_speech:
+                        inside_speech = True
+                    elif token_id == audio_writer.player.end_of_speech:
+                        inside_speech = False
+                    elif inside_speech:
+                        audio_token_count += 1
+
+        point_2 = time.time()
+        generation_time = point_2 - point_1
+
+        # Calculate Real Time Factor (RTF)
+        # Audio codec runs at 12.5 fps, audio tokens come in groups of 4 per frame
+        FRAMES_PER_SECOND = 12.5
+        TOKENS_PER_FRAME = 4
+
+        # Calculate audio duration: tokens / 4 = frames, frames / 12.5 = seconds
+        num_frames = audio_token_count // TOKENS_PER_FRAME
+        audio_duration = num_frames / FRAMES_PER_SECOND
+        rtf = generation_time / audio_duration if audio_duration > 0 else 0
+
+        # Calculate token counts
+        prompt_tokens = len(input_ids)
+        generated_tokens = len(all_token_ids)
+        total_tokens = prompt_tokens + generated_tokens
+
+        print(f"\n[VLLM] Generation complete. Prompt tokens: {prompt_tokens}, Generated tokens: {generated_tokens}, Total: {total_tokens}")
+        print(f"       Audio tokens: {audio_token_count}, Frames: {num_frames}, Audio duration: {audio_duration:.2f}s")
+        print(f"       Generation time: {generation_time:.2f}s, RTF: {rtf:.3f}")
+
+        # OPTIMIZATION: Skip text decoding - it's slow and not needed for TTS
+
+        return {
+            'all_token_ids': all_token_ids,
+            'generation_time': generation_time,
+            'audio_duration': audio_duration,
+            'rtf': rtf,
+            'point_1': point_1,
+            'point_2': point_2
+        }
+
+    def generate(self, prompt, audio_writer, max_tokens=MAX_TOKENS, reference_audio_tokens=None):
+        """Generate speech tokens from text prompt with streaming
+
+        This is a synchronous wrapper around the async streaming implementation.
+
+        Args:
+            prompt: Text prompt to convert to speech
+            audio_writer: StreamingAudioWriter instance to receive tokens
+            max_tokens: Maximum number of tokens to generate
+
+        Returns:
+            Dictionary with generation metrics and results
+        """
+        # Try to get the current event loop, or create a new one if needed
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            # No event loop running, create one
+            return asyncio.run(self._generate_async(prompt, audio_writer, max_tokens, reference_audio_tokens=reference_audio_tokens))
+        else:
+            # Event loop is running, we need to run in a thread pool
+            import concurrent.futures
+            import threading
+
+            result = None
+            exception = None
+
+            def run_in_new_loop():
+                nonlocal result, exception
+                try:
+                    new_loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(new_loop)
+                    result = new_loop.run_until_complete(
+                        self._generate_async(
+                            prompt,
+                            audio_writer,
+                            max_tokens,
+                            reference_audio_tokens=reference_audio_tokens,
+                        )
+                    )
+                    new_loop.close()
+                except Exception as e:
+                    exception = e
+
+            thread = threading.Thread(target=run_in_new_loop)
+            thread.start()
+            thread.join()
+
+            if exception:
+                raise exception
+
+            return result
+
+    async def generate_long_form_async(self, text, reference_audio_tokens, player, max_chunk_duration=12.0,
+                                       silence_duration=0.2, max_tokens=MAX_TOKENS):
+        """Generate speech for long text by splitting into chunks with shared reference audio.
+
+        This method handles texts longer than the model's training distribution (5-15s)
+        by splitting into sentence-based chunks and generating each with the same voice.
+
+        Args:
+            text: Input text (can be any length)
+            reference_audio_tokens: Flattened reference audio token sequence reused for each chunk
+            player: LLMAudioPlayer instance for decoding audio
+            max_chunk_duration: Target duration per chunk in seconds (default 12s)
+            silence_duration: Duration of silence between chunks in seconds (default 0.2s)
+            max_tokens: Maximum tokens per generation
+
+        Returns:
+            Dictionary with:
+                - audio: Concatenated audio as numpy array
+                - chunks_info: List of info dicts for each chunk
+                - total_duration: Total audio duration in seconds
+                - total_generation_time: Total time spent generating
+        """
+        from generation.chunking import split_into_sentences, estimate_duration
+        from audio.streaming import StreamingAudioWriter
+
+        # Estimate if text needs chunking
+        estimated_duration = estimate_duration(text)
+        print(f"\n[Long-form] Estimated duration: {estimated_duration:.1f}s for text length: {len(text)} chars")
+
+        # Split into chunks
+        chunks = split_into_sentences(text, max_duration_seconds=max_chunk_duration)
+        print(f"[Long-form] Split into {len(chunks)} chunks")
+
+        if len(chunks) == 1:
+            print("[Long-form] Single chunk - using standard generation")
+
+        # Generate each chunk with the same reference audio tokens for consistency
+        audio_segments = []
+        chunks_info = []
+        total_generation_time = 0
+
+        for i, chunk in enumerate(chunks):
+            print(f"\n[Long-form] Generating chunk {i+1}/{len(chunks)}: '{chunk[:50]}...'")
+
+            prompt = chunk
+
+            # Create audio writer for this chunk
+            audio_writer = StreamingAudioWriter(
+                player,
+                output_file=None,  # Don't write to file
+                chunk_size=25,     # Use default chunk size
+                lookback_frames=15  # Use default lookback
+            )
+            audio_writer.start()
+
+            # Generate this chunk
+            result = await self._generate_async(
+                prompt,
+                audio_writer,
+                max_tokens=max_tokens,
+                reference_audio_tokens=reference_audio_tokens,
+            )
+
+            # Finalize and get audio
+            audio = audio_writer.finalize()
+
+            if audio is not None and len(audio) > 0:
+                audio_segments.append(audio)
+                chunks_info.append({
+                    'chunk_index': i,
+                    'text': chunk,
+                    'duration': result['audio_duration'],
+                    'generation_time': result['generation_time'],
+                    'rtf': result['rtf']
+                })
+                total_generation_time += result['generation_time']
+            else:
+                print(f"[Long-form] Warning: No audio generated for chunk {i+1}")
+
+        # Concatenate audio segments with silence
+        if len(audio_segments) == 0:
+            raise ValueError("No audio was generated")
+
+        if len(audio_segments) == 1:
+            final_audio = audio_segments[0]
+        else:
+            final_audio = self._concatenate_with_silence(
+                audio_segments,
+                silence_duration=silence_duration
+            )
+
+        total_duration = len(final_audio) / SAMPLE_RATE
+
+        print(f"\n[Long-form] Complete!")
+        print(f"  Total chunks: {len(chunks)}")
+        print(f"  Total duration: {total_duration:.2f}s")
+        print(f"  Total generation time: {total_generation_time:.2f}s")
+        print(f"  Overall RTF: {total_generation_time / total_duration:.3f}")
+
+        return {
+            'audio': final_audio,
+            'chunks_info': chunks_info,
+            'total_duration': total_duration,
+            'total_generation_time': total_generation_time,
+            'num_chunks': len(chunks)
+        }
+
+    def _concatenate_with_silence(self, audio_segments, silence_duration=0.2):
+        """Concatenate audio segments with short silence between them
+
+        Args:
+            audio_segments: List of numpy audio arrays
+            silence_duration: Duration of silence in seconds
+
+        Returns:
+            Concatenated audio as numpy array
+        """
+        if len(audio_segments) == 1:
+            return audio_segments[0]
+
+        # Create silence buffer (zeros)
+        silence_samples = int(silence_duration * SAMPLE_RATE)
+        silence = np.zeros(silence_samples, dtype=audio_segments[0].dtype)
+
+        # Concatenate segments with silence in between
+        result = audio_segments[0]
+        for next_segment in audio_segments[1:]:
+            result = np.concatenate([result, silence, next_segment])
+
+        return result

render_radio_play.py

@@ -0,0 +1,198 @@
+import argparse
+import json
+import re
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+import requests
+import soundfile as sf
+
+
+SAMPLE_RATE = 22050
+PUNCTUATION = ("!", "?", ".", ",")
+LINE_PATTERN = re.compile(r"^\[(?P<speaker>[^\]]+)\]:\s*(?P<text>.*)$")
+
+
+@dataclass
+class ScriptLine:
+    line_number: int
+    speaker: str
+    text: str
+
+
+@dataclass
+class Chunk:
+    segment_id: int
+    chunk_id: int
+    line_number: int
+    speaker: str
+    text: str
+    reference_audio_path: Path
+
+
+def parse_script(script_path: Path) -> list[ScriptLine]:
+    items: list[ScriptLine] = []
+    for line_number, raw_line in enumerate(script_path.read_text(encoding="utf-8").splitlines(), start=1):
+        stripped = raw_line.strip()
+        if not stripped:
+            continue
+        match = LINE_PATTERN.match(stripped)
+        if not match:
+            raise ValueError(f"Invalid script line {line_number}: {raw_line}")
+        text = re.sub(r"\s+", " ", match.group("text")).strip()
+        if not text:
+            continue
+        items.append(ScriptLine(line_number=line_number, speaker=match.group("speaker"), text=text))
+    return items
+
+
+def split_text(text: str, max_chars: int) -> list[str]:
+    remaining = text.strip()
+    parts: list[str] = []
+    while len(remaining) > max_chars:
+        window = remaining[:max_chars]
+        split_at = max(window.rfind(mark) for mark in PUNCTUATION)
+        if split_at <= 0:
+            split_at = window.rfind(" ")
+        if split_at <= 0:
+            split_at = max_chars
+        else:
+            split_at += 1
+
+        part = remaining[:split_at].strip()
+        if part:
+            parts.append(part)
+        remaining = remaining[split_at:].lstrip()
+
+    if remaining:
+        parts.append(remaining)
+    return parts
+
+
+def build_chunks(lines: list[ScriptLine], ref_dir: Path, max_chars: int) -> list[Chunk]:
+    chunks: list[Chunk] = []
+    for segment_id, line in enumerate(lines):
+        ref_path = ref_dir / f"{line.speaker}.wav"
+        if not ref_path.exists():
+            raise FileNotFoundError(f"Missing reference audio for speaker '{line.speaker}': {ref_path}")
+        for chunk_id, part in enumerate(split_text(line.text, max_chars), start=1):
+            chunks.append(
+                Chunk(
+                    segment_id=segment_id,
+                    chunk_id=chunk_id,
+                    line_number=line.line_number,
+                    speaker=line.speaker,
+                    text=part,
+                    reference_audio_path=ref_path,
+                )
+            )
+    return chunks
+
+
+def synthesize_chunk(session: requests.Session, server_url: str, chunk: Chunk) -> tuple[np.ndarray, dict]:
+    payload = {
+        "input": chunk.text,
+        "model": "tts-1",
+        "reference_audio_path": str(chunk.reference_audio_path),
+        "response_format": "pcm",
+        "enable_long_form": False,
+    }
+    started = time.perf_counter()
+    response = session.post(server_url, json=payload, timeout=300)
+    elapsed = time.perf_counter() - started
+    response.raise_for_status()
+
+    pcm = np.frombuffer(response.content, dtype=np.int16).astype(np.float32) / 32768.0
+    duration = len(pcm) / SAMPLE_RATE
+    return pcm, {
+        "segment_id": chunk.segment_id,
+        "chunk_id": chunk.chunk_id,
+        "line_number": chunk.line_number,
+        "speaker": chunk.speaker,
+        "text": chunk.text,
+        "reference_audio_path": str(chunk.reference_audio_path),
+        "latency_seconds": elapsed,
+        "audio_duration_seconds": duration,
+        "rtf": elapsed / duration if duration else None,
+        "pcm_bytes": len(response.content),
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Render a radio play script through the local KaniTTS FastAPI server.")
+    parser.add_argument("--script", type=Path, required=True)
+    parser.add_argument("--ref-dir", type=Path, required=True)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument("--server-url", default="http://127.0.0.1:8010/v1/audio/speech")
+    parser.add_argument("--max-chars", type=int, default=180)
+    parser.add_argument("--same-line-pause-ms", type=float, default=60.0)
+    parser.add_argument("--line-pause-ms", type=float, default=180.0)
+    args = parser.parse_args()
+
+    lines = parse_script(args.script)
+    chunks = build_chunks(lines, args.ref_dir, args.max_chars)
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    output_wav = args.output_dir / f"{args.script.stem}_radio_play.wav"
+    output_json = args.output_dir / f"{args.script.stem}_report.json"
+
+    same_line_pause = np.zeros(int(SAMPLE_RATE * args.same_line_pause_ms / 1000.0), dtype=np.float32)
+    line_pause = np.zeros(int(SAMPLE_RATE * args.line_pause_ms / 1000.0), dtype=np.float32)
+
+    rendered_audio: list[np.ndarray] = []
+    report_chunks: list[dict] = []
+    total_started = time.perf_counter()
+
+    with requests.Session() as session:
+        for index, chunk in enumerate(chunks, start=1):
+            audio, chunk_report = synthesize_chunk(session, args.server_url, chunk)
+            rendered_audio.append(audio)
+            report_chunks.append(chunk_report)
+
+            next_chunk = chunks[index] if index < len(chunks) else None
+            if next_chunk is not None:
+                if next_chunk.segment_id == chunk.segment_id:
+                    rendered_audio.append(same_line_pause)
+                else:
+                    rendered_audio.append(line_pause)
+
+            print(
+                f"[{index}/{len(chunks)}] {chunk.speaker} line {chunk.line_number} part {chunk.chunk_id}: "
+                f"{chunk_report['audio_duration_seconds']:.2f}s audio in {chunk_report['latency_seconds']:.2f}s "
+                f"RTF={chunk_report['rtf']:.3f}"
+            )
+
+    total_elapsed = time.perf_counter() - total_started
+    full_audio = np.concatenate(rendered_audio) if rendered_audio else np.zeros(0, dtype=np.float32)
+    sf.write(output_wav, full_audio, SAMPLE_RATE)
+
+    total_audio_duration = len(full_audio) / SAMPLE_RATE
+    report = {
+        "script": str(args.script),
+        "ref_dir": str(args.ref_dir),
+        "server_url": args.server_url,
+        "max_chars": args.max_chars,
+        "source_lines": len(lines),
+        "rendered_chunks": len(chunks),
+        "total_latency_seconds": total_elapsed,
+        "total_audio_duration_seconds": total_audio_duration,
+        "overall_rtf": total_elapsed / total_audio_duration if total_audio_duration else None,
+        "output_wav": str(output_wav),
+        "chunks": report_chunks,
+    }
+    output_json.write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    print("\nRender complete")
+    print(f"Output WAV: {output_wav}")
+    print(f"Report JSON: {output_json}")
+    print(f"Source lines: {len(lines)}")
+    print(f"Rendered chunks: {len(chunks)}")
+    print(f"Total audio duration: {total_audio_duration:.2f}s")
+    print(f"Total latency: {total_elapsed:.2f}s")
+    print(f"Overall RTF: {report['overall_rtf']:.3f}")
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+vllm
+nemo-toolkit[tts]==2.4.0
+transformers==4.57.1
+torch
+numpy
+scipy
+soundfile

server.py

@@ -0,0 +1,422 @@
+"""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
+
+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
+                print(f"[Server] Using standard generation (estimated {estimated_duration:.1f}s)")
+                audio_writer = StreamingAudioWriter(
+                    player,
+                    output_file=None,
+                    chunk_size=CHUNK_SIZE,
+                    lookback_frames=LOOKBACK_FRAMES
+                )
+                audio_writer.start()
+
+                # Generate speech
+                result = await generator._generate_async(
+                    prompt_text,
+                    audio_writer,
+                    max_tokens=MAX_TOKENS,
+                    reference_audio_tokens=reference_audio_tokens,
+                )
+
+                # Finalize and get audio
+                audio_writer.finalize()
+
+                if not audio_writer.audio_chunks:
+                    raise HTTPException(status_code=500, detail="No audio generated")
+
+                # Concatenate all chunks
+                full_audio = np.concatenate(audio_writer.audio_chunks)
+
+            # 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)

test_rtf.py

@@ -0,0 +1,54 @@
+"""Quick test to verify RTF output"""
+
+import asyncio
+import os
+from generation.vllm_generator import VLLMTTSGenerator
+from audio import LLMAudioPlayer, StreamingAudioWriter
+from config import CHUNK_SIZE, LOOKBACK_FRAMES, REF_AUDIO_SECONDS, GPU_MEMORY_UTILIZATION, MAX_MODEL_LEN
+
+async def main():
+    print("Initializing VLLM generator...")
+    generator = VLLMTTSGenerator(
+        tensor_parallel_size=1,
+        gpu_memory_utilization=GPU_MEMORY_UTILIZATION,
+        max_model_len=MAX_MODEL_LEN,
+    )
+
+    # Initialize engine
+    await generator.initialize_engine()
+
+    player = LLMAudioPlayer(generator.tokenizer)
+
+    prompt = "Това е кратък тест за real-time factor на ref-audio сървъра."
+    reference_audio_path = os.environ.get("KANITTS_TEST_REF_AUDIO", "/home/nasko/besttts/REF/woman.wav")
+    reference_audio_tokens, reference_frames = player.prepare_reference_audio_tokens(
+        reference_audio_path=reference_audio_path,
+        ref_seconds=REF_AUDIO_SECONDS,
+    )
+    print(f"Reference frames: {reference_frames}")
+
+    audio_writer = StreamingAudioWriter(
+        player,
+        output_file=None,
+        chunk_size=CHUNK_SIZE,
+        lookback_frames=LOOKBACK_FRAMES
+    )
+    audio_writer.start()
+
+    # Generate
+    result = await generator._generate_async(
+        prompt,
+        audio_writer,
+        reference_audio_tokens=reference_audio_tokens,
+    )
+    audio_writer.finalize()
+
+    # Print results
+    print(f"\nResults:")
+    print(f"  Tokens: {len(result['all_token_ids'])}")
+    print(f"  Audio duration: {result['audio_duration']:.2f}s")
+    print(f"  Generation time: {result['generation_time']:.2f}s")
+    print(f"  RTF: {result['rtf']:.3f}")
+
+if __name__ == "__main__":
+    asyncio.run(main())