Upload 7 files

Qwen3_TTS_Colab.ipynb

@@ -0,0 +1,97 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "\n",
+        "\n",
+        "### 🏷️ **Credits & License**\n",
+        "\n",
+        "* 🔗 [Qwen3-TTS GitHub Repository](https://github.com/QwenLM/Qwen3-TTS)\n",
+        "* 🤗 [Qwen3-TTS on Hugging Face](https://huggingface.co/collections/Qwen/qwen3-tts)\n",
+        "* 📄 **License**: Provided under the [Apache License 2.0](https://github.com/QwenLM/Qwen3-TTS?tab=Apache-2.0-1-ov-file)\n",
+        "* 🤗 [Try Qwen3-TTS on HuggingFace Space](https://huggingface.co/spaces/Qwen/Qwen3-TTS)\n",
+        "\n",
+        "\n",
+        "\n",
+        "### ⚠️ **Usage Disclaimer**\n",
+        "\n",
+        "Use of this voice cloning model is subject to strict ethical and legal standards. By using this tool, you agree **not to** engage in any of the following prohibited activities:\n",
+        "\n",
+        "* **Fraud or Deception**: Using cloned voices to create misleading or fraudulent content.\n",
+        "* **Impersonation**: Replicating someone’s voice without their explicit permission, especially for malicious, harmful, or deceptive purposes.\n",
+        "* **Illegal Activities**: Employing the model in any manner that violates local, national, or international laws and regulations.\n",
+        "* **Harmful Content Generation**: Creating offensive, defamatory, or unethical material, including content that spreads misinformation or causes harm.\n",
+        "\n",
+        "> ⚖️ **Legal Responsibility**\n",
+        "> The developers of this tool disclaim all liability for misuse. **Users bear full responsibility** for ensuring that their usage complies with all applicable laws, regulations, and ethical guidelines.\n",
+        "\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "O5hhJS2moOhU"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "cellView": "form",
+        "id": "57sW-0cHjthT"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Install Qwen3-TTS\n",
+        "%cd /content/\n",
+        "# !rm -rf /content/Qwen3-TTS-Colab\n",
+        "!git clone https://github.com/NeuralFalconYT/Qwen3-TTS-Colab.git\n",
+        "!git clone https://github.com/QwenLM/Qwen3-TTS.git\n",
+        "%cd Qwen3-TTS\n",
+        "!pip install -e .\n",
+        "!pip install faster-whisper==1.1.1\n",
+        "!pip install ctranslate2==4.5.0\n",
+        "!pip install pysrt\n",
+        "!pip install sentencex\n",
+        "from IPython.display import Audio,display\n",
+        "from IPython.display import clear_output\n",
+        "import time\n",
+        "clear_output()\n",
+        "\n",
+        "display(Audio(\"https://raw.githubusercontent.com/NeuralFalconYT/Useful-Function/refs/heads/main/audio/warning.mp3\", autoplay=True))\n",
+        "time.sleep(6)\n",
+        "clear_output()\n",
+        "# time.sleep(5)\n",
+        "# import os\n",
+        "# os.kill(os.getpid(), 9)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "%cd /content/Qwen3-TTS-Colab\n",
+        "!python app.py --share --debug"
+      ],
+      "metadata": {
+        "id": "v7Y8L5EDpYNU"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

README.md

@@ -1,14 +1,11 @@
----
-title: Qwen3 TTS Colab
-emoji: 🦀
-colorFrom: blue
-colorTo: blue
-sdk: gradio
-sdk_version: 6.4.0
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: Run Qwen3-TTS On Google Colab
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Run Qwen3 TTS on Google Colab
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NeuralFalconYT/Qwen3-TTS-Colab/blob/main/Qwen3_TTS_Colab.ipynb) <br>
+
+
+![1](https://github.com/user-attachments/assets/e2602945-1a69-4c59-ad89-e95d96ba7858)
+
+## Credit:
+[Qwen3-TTS](https://github.com/QwenLM/Qwen3-TTS)
+
+## Disclaimer
+Don't use this model to do bad things. 

app.py

@@ -0,0 +1,534 @@
+# %cd /content/Qwen3-TTS-Colab
+from subtitle import subtitle_maker
+from process_text import text_chunk
+from qwen_tts import Qwen3TTSModel
+import subprocess
+import os
+import gradio as gr
+import numpy as np
+import torch
+import soundfile as sf
+from pydub import AudioSegment
+from pydub.silence import split_on_silence
+from huggingface_hub import snapshot_download
+from hf_downloader import download_model
+import gc 
+from huggingface_hub import login
+
+HF_TOKEN = os.getenv("HF_TOKEN")
+if HF_TOKEN:
+    login(token=HF_TOKEN)
+else:
+  HF_TOKEN=None
+
+# Global model holders
+loaded_models = {}
+MODEL_SIZES = ["0.6B", "1.7B"]
+
+# Speaker and language choices
+SPEAKERS = [
+    "Aiden", "Dylan", "Eric", "Ono_anna", "Ryan", "Serena", "Sohee", "Uncle_fu", "Vivian"
+]
+LANGUAGES = ["Auto", "Chinese", "English", "Japanese", "Korean", "French", "German", "Spanish", "Portuguese", "Russian"]
+
+# --- Helper Functions ---
+
+def get_model_path(model_type: str, model_size: str) -> str:
+    """Get model path based on type and size."""
+    try:
+      return snapshot_download(f"Qwen/Qwen3-TTS-12Hz-{model_size}-{model_type}")
+    except Exception as e:
+      return download_model(f"Qwen/Qwen3-TTS-12Hz-{model_size}-{model_type}", download_folder="./qwen_tts_model", redownload= False)
+
+def clear_other_models(keep_key=None):
+    """Delete all loaded models except the current one."""
+    global loaded_models
+    keys_to_delete = [k for k in loaded_models if k != keep_key]
+    for k in keys_to_delete:
+        try:
+            del loaded_models[k]
+        except Exception:
+            pass
+    for k in keys_to_delete:
+        loaded_models.pop(k, None)
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+def get_model(model_type: str, model_size: str):
+    """Load model and clear others to avoid OOM in Colab."""
+    global loaded_models
+    key = (model_type, model_size)
+    if key in loaded_models:
+        return loaded_models[key]
+    
+    clear_other_models(keep_key=key)
+    model_path = get_model_path(model_type, model_size)
+    model = Qwen3TTSModel.from_pretrained(
+        model_path,
+        device_map="cuda",
+        dtype=torch.bfloat16,
+    )
+    loaded_models[key] = model
+    return model
+
+def _normalize_audio(wav, eps=1e-12, clip=True):
+    """Normalize audio to float32 in [-1, 1] range."""
+    x = np.asarray(wav)
+    if np.issubdtype(x.dtype, np.integer):
+        info = np.iinfo(x.dtype)
+        if info.min < 0:
+            y = x.astype(np.float32) / max(abs(info.min), info.max)
+        else:
+            mid = (info.max + 1) / 2.0
+            y = (x.astype(np.float32) - mid) / mid
+    elif np.issubdtype(x.dtype, np.floating):
+        y = x.astype(np.float32)
+        m = np.max(np.abs(y)) if y.size else 0.0
+        if m > 1.0 + 1e-6:
+            y = y / (m + eps)
+    else:
+        raise TypeError(f"Unsupported dtype: {x.dtype}")
+    if clip:
+        y = np.clip(y, -1.0, 1.0)
+    if y.ndim > 1:
+        y = np.mean(y, axis=-1).astype(np.float32)
+    return y
+
+def _audio_to_tuple(audio):
+    """Convert Gradio audio input to (wav, sr) tuple."""
+    if audio is None: return None
+    if isinstance(audio, str):
+        try:
+            wav, sr = sf.read(audio)
+            wav = _normalize_audio(wav)
+            return wav, int(sr)
+        except Exception as e:
+            print(f"Error reading audio file: {e}")
+            return None
+    if isinstance(audio, tuple) and len(audio) == 2 and isinstance(audio[0], int):
+        sr, wav = audio
+        wav = _normalize_audio(wav)
+        return wav, int(sr)
+    if isinstance(audio, dict) and "sampling_rate" in audio and "data" in audio:
+        sr = int(audio["sampling_rate"])
+        wav = _normalize_audio(audio["data"])
+        return wav, sr
+    return None
+
+def transcribe_reference(audio_path, mode_input, language="English"):
+    """Uses subtitle_maker to extract text from the reference audio."""
+    should_run = False
+    if isinstance(mode_input, bool): should_run = mode_input
+    elif isinstance(mode_input, str) and "High-Quality" in mode_input: should_run = True
+
+    if not audio_path or not should_run: return gr.update()
+    
+    print(f"Starting transcription for: {audio_path}")
+    src_lang = language if language != "Auto" else "English"
+    try:
+        results = subtitle_maker(audio_path, src_lang)
+        transcript = results[7]
+        return transcript if transcript else "Could not detect speech."
+    except Exception as e:
+        print(f"Transcription Error: {e}")
+        return f"Error during transcription: {str(e)}"
+
+# --- Audio Processing Utils (Disk Based) ---
+
+def remove_silence_function(file_path, minimum_silence=100):
+    """Removes silence from an audio file using Pydub."""
+    try:
+        output_path = file_path.replace(".wav", "_no_silence.wav")
+        sound = AudioSegment.from_wav(file_path)
+        audio_chunks = split_on_silence(sound,
+                                        min_silence_len=minimum_silence,
+                                        silence_thresh=-45,
+                                        keep_silence=50)
+        combined = AudioSegment.empty()
+        for chunk in audio_chunks:
+            combined += chunk
+        combined.export(output_path, format="wav")
+        return output_path
+    except Exception as e:
+        print(f"Error removing silence: {e}")
+        return file_path
+
+def process_audio_output(audio_path, make_subtitle, remove_silence, language="Auto"):
+    """Handles Silence Removal and Subtitle Generation."""
+    # 1. Remove Silence
+    final_audio_path = audio_path
+    if remove_silence:
+        final_audio_path = remove_silence_function(audio_path)
+    
+    # 2. Generate Subtitles
+    default_srt, custom_srt, word_srt, shorts_srt = None, None, None, None
+    if make_subtitle:
+        try:
+            results = subtitle_maker(final_audio_path, language)
+            default_srt = results[0]
+            custom_srt = results[1]
+            word_srt = results[2]
+            shorts_srt = results[3]
+        except Exception as e:
+            print(f"Subtitle generation error: {e}")
+
+    return final_audio_path, default_srt, custom_srt, word_srt, shorts_srt
+
+def stitch_chunk_files(chunk_files):
+    """
+    Takes a list of file paths.
+    Stitches them into one file.
+    Deletes the temporary chunk files.
+    """
+    if not chunk_files:
+        return None
+
+    combined_audio = AudioSegment.empty()
+    
+    print(f"Stitching {len(chunk_files)} audio files...")
+    for f in chunk_files:
+        try:
+            segment = AudioSegment.from_wav(f)
+            combined_audio += segment
+        except Exception as e:
+            print(f"Error appending chunk {f}: {e}")
+            
+    output_filename = f"final_output_{os.getpid()}.wav"
+    combined_audio.export(output_filename, format="wav")
+    
+    # Clean up temp files
+    for f in chunk_files:
+        try:
+            if os.path.exists(f):
+                os.remove(f)
+        except Exception as e:
+            print(f"Warning: Could not delete temp file {f}: {e}")
+            
+    return output_filename
+
+# --- Generators (Memory Optimized) ---
+
+def generate_voice_design(text, language, voice_description, remove_silence, make_subs):
+    if not text or not text.strip(): return None, "Error: Text is required.", None, None, None, None
+    
+    try:
+        # 1. Chunk Text
+        text_chunks, tts_filename = text_chunk(text, language, char_limit=280)
+        print(f"Processing {len(text_chunks)} chunks...")
+        
+        chunk_files = []
+        tts = get_model("VoiceDesign", "1.7B")
+
+        # 2. Generate & Save Loop
+        for i, chunk in enumerate(text_chunks):
+            wavs, sr = tts.generate_voice_design(
+                text=chunk.strip(),
+                language=language,
+                instruct=voice_description.strip(),
+                non_streaming_mode=True,
+                max_new_tokens=2048,
+            )
+            
+            # Save immediately to disk
+            temp_filename = f"temp_chunk_{i}_{os.getpid()}.wav"
+            sf.write(temp_filename, wavs[0], sr)
+            chunk_files.append(temp_filename)
+            
+            # Clear memory
+            del wavs
+            torch.cuda.empty_cache()
+            gc.collect()
+        
+        # 3. Stitch from disk
+        stitched_file = stitch_chunk_files(chunk_files)
+        
+        # 4. Post-Process
+        final_audio, srt1, srt2, srt3, srt4 = process_audio_output(stitched_file, make_subs, remove_silence, language)
+        
+        return final_audio, "Generation Success!", srt1, srt2, srt3, srt4
+
+    except Exception as e:
+        return None, f"Error: {e}", None, None, None, None
+
+def generate_custom_voice(text, language, speaker, instruct, model_size, remove_silence, make_subs):
+    if not text or not text.strip(): return None, "Error: Text is required.", None, None, None, None
+    
+    try:
+        text_chunks, tts_filename = text_chunk(text, language, char_limit=280)
+        chunk_files = []
+        tts = get_model("CustomVoice", model_size)
+        formatted_speaker = speaker.lower().replace(" ", "_")
+
+        for i, chunk in enumerate(text_chunks):
+            wavs, sr = tts.generate_custom_voice(
+                text=chunk.strip(),
+                language=language,
+                speaker=formatted_speaker,
+                instruct=instruct.strip() if instruct else None,
+                non_streaming_mode=True,
+                max_new_tokens=2048,
+            )
+            # Save immediately
+            temp_filename = f"temp_custom_{i}_{os.getpid()}.wav"
+            sf.write(temp_filename, wavs[0], sr)
+            chunk_files.append(temp_filename)
+            
+            # Clear memory
+            del wavs
+            torch.cuda.empty_cache()
+            gc.collect()
+            
+        stitched_file = stitch_chunk_files(chunk_files)
+        final_audio, srt1, srt2, srt3, srt4 = process_audio_output(stitched_file, make_subs, remove_silence, language)
+        return final_audio, "Generation Success!", srt1, srt2, srt3, srt4
+
+    except Exception as e:
+        return None, f"Error: {e}", None, None, None, None
+
+def smart_generate_clone(ref_audio, ref_text, target_text, language, mode, model_size, remove_silence, make_subs):
+    if not target_text or not target_text.strip(): return None, "Error: Target text is required.", None, None, None, None
+    if not ref_audio: return None, "Error: Ref audio required.", None, None, None, None
+
+    # 1. Mode & Transcript Logic
+    use_xvector_only = ("Fast" in mode)
+    final_ref_text = ref_text
+    audio_tuple = _audio_to_tuple(ref_audio)
+
+    if not use_xvector_only:
+        if not final_ref_text or not final_ref_text.strip():
+            print("Auto-transcribing reference...")
+            try:
+                final_ref_text = transcribe_reference(ref_audio, True, language)
+                if not final_ref_text or "Error" in final_ref_text:
+                     return None, f"Transcription failed: {final_ref_text}", None, None, None, None
+            except Exception as e:
+                return None, f"Transcribe Error: {e}", None, None, None, None
+    else:
+        final_ref_text = None
+
+    try:
+        # 2. Chunk Target Text
+        text_chunks, tts_filename = text_chunk(target_text, language, char_limit=280)
+        chunk_files = []
+        tts = get_model("Base", model_size)
+
+        # 3. Generate Loop
+        for i, chunk in enumerate(text_chunks):
+            wavs, sr = tts.generate_voice_clone(
+                text=chunk.strip(),
+                language=language,
+                ref_audio=audio_tuple,
+                ref_text=final_ref_text.strip() if final_ref_text else None,
+                x_vector_only_mode=use_xvector_only,
+                max_new_tokens=2048,
+            )
+            # Save immediately
+            temp_filename = f"temp_clone_{i}_{os.getpid()}.wav"
+            sf.write(temp_filename, wavs[0], sr)
+            chunk_files.append(temp_filename)
+
+            # Clear memory
+            del wavs
+            torch.cuda.empty_cache()
+            gc.collect()
+
+        # 4. Stitch & Process
+        stitched_file = stitch_chunk_files(chunk_files)
+        final_audio, srt1, srt2, srt3, srt4 = process_audio_output(stitched_file, make_subs, remove_silence, language)
+        return final_audio, f"Success! Mode: {mode}", srt1, srt2, srt3, srt4
+
+    except Exception as e:
+        return None, f"Error: {e}", None, None, None, None
+
+
+# --- UI Construction ---
+
+def on_mode_change(mode):
+    return gr.update(visible=("High-Quality" in mode))
+
+def build_ui():
+    theme = gr.themes.Soft(font=[gr.themes.GoogleFont("Source Sans Pro"), "Arial", "sans-serif"])
+    css = ".gradio-container {max-width: none !important;} .tab-content {padding: 20px;}"
+
+    with gr.Blocks(theme=theme, css=css, title="Qwen3-TTS Demo") as demo:
+        gr.HTML("""
+        <div style="text-align: center; margin: 20px auto; max-width: 800px;">
+            <h1 style="font-size: 2.5em; margin-bottom: 5px;">🎙️ Qwen3-TTS </h1>
+            <a href="https://colab.research.google.com/github/NeuralFalconYT/Qwen3-TTS-Colab/blob/main/Qwen3_TTS_Colab.ipynb" target="_blank" style="display: inline-block; padding: 10px 20px; background-color: #4285F4; color: white; border-radius: 6px; text-decoration: none; font-size: 1em;">🥳 Run on Google Colab</a>
+        </div>""")
+
+        with gr.Tabs():
+            # --- Tab 1: Voice Design ---
+            with gr.Tab("Voice Design"):
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        design_text = gr.Textbox(label="Text to Synthesize", lines=4, value="It's in the top drawer... wait, it's empty? No way, that's impossible! I'm sure I put it there!",
+                                                 placeholder="Enter the text you want to convert to speech...")
+                        design_language = gr.Dropdown(label="Language", choices=LANGUAGES, value="Auto")
+                        design_instruct = gr.Textbox(label="Voice Description", lines=3,  placeholder="Describe the voice characteristics you want...",
+                            value="Speak in an incredulous tone, but with a hint of panic beginning to creep into your voice.")
+                        design_btn = gr.Button("Generate with Custom Voice", variant="primary")
+                        with gr.Accordion("More options", open=False):
+                            with gr.Row():
+                              design_rem_silence = gr.Checkbox(label="Remove Silence", value=False)
+                              design_make_subs = gr.Checkbox(label="Generate Subtitles", value=False)
+                        
+                        
+
+                    with gr.Column(scale=2):
+                        design_audio_out = gr.Audio(label="Generated Audio", type="filepath")
+                        design_status = gr.Textbox(label="Status", interactive=False)
+                        
+                        with gr.Accordion("📝 Subtitles", open=False):
+                            with gr.Row():
+                                d_srt1 = gr.File(label="Original (Whisper)")
+                                d_srt2 = gr.File(label="Readable")
+                            with gr.Row():
+                                d_srt3 = gr.File(label="Word-level")
+                                d_srt4 = gr.File(label="Shorts/Reels")
+
+                design_btn.click(
+                    generate_voice_design, 
+                    inputs=[design_text, design_language, design_instruct, design_rem_silence, design_make_subs], 
+                    outputs=[design_audio_out, design_status, d_srt1, d_srt2, d_srt3, d_srt4]
+                )
+
+            # --- Tab 2: Voice Clone ---
+            with gr.Tab("Voice Clone (Base)"):
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        clone_target_text = gr.Textbox(label="Target Text", lines=3, placeholder="Enter the text you want the cloned voice to speak...")
+                        clone_ref_audio = gr.Audio(label="Reference Audio (Upload a voice sample to clone)", type="filepath")
+                        
+                        with gr.Row():
+                            clone_language = gr.Dropdown(label="Language", choices=LANGUAGES, value="Auto",scale=1)
+                            clone_model_size = gr.Dropdown(label="Model Size", choices=MODEL_SIZES, value="1.7B",scale=1)
+                            clone_mode = gr.Dropdown(
+                                label="Mode",
+                                choices=["High-Quality (Audio + Transcript)", "Fast (Audio Only)"],
+                                value="High-Quality (Audio + Transcript)",
+                                interactive=True,
+                                scale=2
+                            )
+                        
+                        clone_ref_text = gr.Textbox(label="Reference Text", lines=2, visible=True)
+                        clone_btn = gr.Button("Clone & Generate", variant="primary")
+                        with gr.Accordion("More options", open=False):
+                            with gr.Row():
+                              clone_rem_silence = gr.Checkbox(label="Remove Silence", value=False)
+                              clone_make_subs = gr.Checkbox(label="Generate Subtitles", value=False)
+
+                        
+
+                    with gr.Column(scale=2):
+                        clone_audio_out = gr.Audio(label="Generated Audio", type="filepath")
+                        clone_status = gr.Textbox(label="Status", interactive=False)
+                        
+                        with gr.Accordion("📝 Subtitles", open=False):
+                            with gr.Row():
+                                c_srt1 = gr.File(label="Original")
+                                c_srt2 = gr.File(label="Readable")
+                            with gr.Row():
+                                c_srt3 = gr.File(label="Word-level")
+                                c_srt4 = gr.File(label="Shorts/Reels")
+
+                clone_mode.change(on_mode_change, inputs=[clone_mode], outputs=[clone_ref_text])
+                clone_ref_audio.change(transcribe_reference, inputs=[clone_ref_audio, clone_mode, clone_language], outputs=[clone_ref_text])
+                
+                clone_btn.click(
+                    smart_generate_clone,
+                    inputs=[clone_ref_audio, clone_ref_text, clone_target_text, clone_language, clone_mode, clone_model_size, clone_rem_silence, clone_make_subs],
+                    outputs=[clone_audio_out, clone_status, c_srt1, c_srt2, c_srt3, c_srt4]
+                )
+
+            # --- Tab 3: TTS (CustomVoice) ---
+            with gr.Tab("TTS (CustomVoice)"):
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        tts_text = gr.Textbox(label="Text", lines=4,   placeholder="Enter the text you want to convert to speech...",
+                            value="Hello! Welcome to Text-to-Speech system. This is a demo of our TTS capabilities.")
+                        with gr.Row():
+                            tts_language = gr.Dropdown(label="Language", choices=LANGUAGES, value="English")
+                            tts_speaker = gr.Dropdown(label="Speaker", choices=SPEAKERS, value="Ryan")
+                        with gr.Row():
+                            tts_instruct = gr.Textbox(label="Style Instruction (Optional)", lines=2,placeholder="e.g., Speak in a cheerful and energetic tone")
+                            tts_model_size = gr.Dropdown(label="Size", choices=MODEL_SIZES, value="1.7B")
+                        tts_btn = gr.Button("Generate Speech", variant="primary")
+                        with gr.Accordion("More options", open=False):
+                            with gr.Row():
+                              tts_rem_silence = gr.Checkbox(label="Remove Silence", value=False)
+                              tts_make_subs = gr.Checkbox(label="Generate Subtitles", value=False)
+                            
+                        
+
+                    with gr.Column(scale=2):
+                        tts_audio_out = gr.Audio(label="Generated Audio", type="filepath")
+                        tts_status = gr.Textbox(label="Status", interactive=False)
+                        
+                        with gr.Accordion("📝 Subtitles", open=False):
+                            with gr.Row():
+                                t_srt1 = gr.File(label="Original")
+                                t_srt2 = gr.File(label="Readable")
+                            with gr.Row():
+                                t_srt3 = gr.File(label="Word-level")
+                                t_srt4 = gr.File(label="Shorts/Reels")
+
+                tts_btn.click(
+                    generate_custom_voice, 
+                    inputs=[tts_text, tts_language, tts_speaker, tts_instruct, tts_model_size, tts_rem_silence, tts_make_subs], 
+                    outputs=[tts_audio_out, tts_status, t_srt1, t_srt2, t_srt3, t_srt4]
+                )
+            # --- Tab 4: About ---
+            with gr.Tab("About"):
+                gr.Markdown("""
+                # Qwen3-TTS 
+                A unified Text-to-Speech demo featuring three powerful modes:
+                - **Voice Design**: Create custom voices using natural language descriptions
+                - **Voice Clone (Base)**: Clone any voice from a reference audio
+                - **TTS (CustomVoice)**: Generate speech with predefined speakers and optional style instructions
+
+                Built with [Qwen3-TTS](https://github.com/QwenLM/Qwen3-TTS) by Alibaba Qwen Team.
+                """)
+
+                gr.HTML("""
+                <hr>
+                <p style="color: red; font-weight: bold; font-size: 16px;">
+                NOTE
+                </p>
+                <p>
+                This Gradio UI is not affiliated with the official Qwen3-TTS project and is based on the
+                official Qwen3-TTS demo UI:<br>
+                <a href="https://huggingface.co/spaces/Qwen/Qwen3-TTS" target="_blank">
+                https://huggingface.co/spaces/Qwen/Qwen3-TTS
+                </a>
+                </p>
+
+                <p><b>Additional features:</b></p>
+                <ul>
+                  <li>Automatic transcription support using faster-whisper-large-v3-turbo-ct2</li>
+                  <li>Long text input support</li>
+                  <li>Because we are using Whisper, subtitles are also added</li>
+                </ul>
+                """)
+
+             
+    return demo
+
+# if __name__ == "__main__":
+#     demo = build_ui()
+#     demo.launch(share=True, debug=True)
+
+
+
+import click
+@click.command()
+@click.option("--debug", is_flag=True, default=False, help="Enable debug mode.")
+@click.option("--share", is_flag=True, default=False, help="Enable sharing of the interface.")
+def main(share,debug):
+    demo = build_ui()
+    demo.launch(share=True, debug=True)
+    demo.queue().launch(debug=debug, share=share)
+
+if __name__ == "__main__":
+    main()    

hf_downloader.py

@@ -0,0 +1,92 @@
+import os
+import requests
+import urllib.request
+import urllib.error
+from tqdm.auto import tqdm
+
+
+def download_file(url: str, download_file_path: str, redownload: bool = False) -> bool:
+    """Download a single file with urllib + tqdm progress bar."""
+    base_path = os.path.dirname(download_file_path)
+    os.makedirs(base_path, exist_ok=True)
+
+    # Skip if file already exists
+    if os.path.exists(download_file_path):
+        if redownload:
+            os.remove(download_file_path)
+            tqdm.write(f"♻️ Redownloading: {os.path.basename(download_file_path)}")
+        elif os.path.getsize(download_file_path) > 0:
+            tqdm.write(f"✔️ Skipped (already exists): {os.path.basename(download_file_path)}")
+            return True
+
+    # Try fetching metadata
+    try:
+        request = urllib.request.urlopen(url)
+        total = int(request.headers.get("Content-Length", 0))
+    except urllib.error.URLError as e:
+        print(f"❌ Error: Unable to open URL: {url}")
+        print(f"Reason: {e.reason}")
+        return False
+
+    # Download with progress bar
+    with tqdm(
+        total=total,
+        desc=os.path.basename(download_file_path),
+        unit="B",
+        unit_scale=True,
+        unit_divisor=1024,
+    ) as progress:
+        try:
+            urllib.request.urlretrieve(
+                url,
+                download_file_path,
+                reporthook=lambda count, block_size, total_size: progress.update(block_size),
+            )
+        except urllib.error.URLError as e:
+            print(f"❌ Error: Failed to download {url}")
+            print(f"Reason: {e.reason}")
+            return False
+
+    tqdm.write(f"⬇️ Downloaded: {os.path.basename(download_file_path)}")
+    return True
+
+
+def download_model(repo_id: str, download_folder: str = "./", redownload: bool = False) -> str | None:
+    """
+    Download all files from a Hugging Face repo into a local folder.
+
+    Args:
+        repo_id (str): Hugging Face repo ID, e.g. "IndexTeam/IndexTTS-2"
+        download_folder (str): Path where the model should be stored
+        redownload (bool): If True, re-download files even if they exist
+
+    Returns:
+        str | None: Path to the downloaded model folder, or None on error
+    """
+    # Normalize empty string as current dir
+    if not download_folder.strip():
+        download_folder = "."
+
+    url = f"https://huggingface.co/api/models/{repo_id}"
+    download_dir = os.path.abspath(f"{download_folder.rstrip('/')}/{repo_id.split('/')[-1]}")
+    os.makedirs(download_dir, exist_ok=True)
+
+    print(f"📂 Download directory: {download_dir}")
+
+    response = requests.get(url)
+    if response.status_code != 200:
+        print("❌ Error:", response.status_code, response.text)
+        return None
+
+    data = response.json()
+    siblings = data.get("siblings", [])
+    files = [f["rfilename"] for f in siblings]
+
+    print(f"📦 Found {len(files)} files in repo '{repo_id}'. Checking cache ...")
+
+    for file in tqdm(files, desc="Processing files", unit="file"):
+        file_url = f"https://huggingface.co/{repo_id}/resolve/main/{file}"
+        file_path = os.path.join(download_dir, file)
+        download_file(file_url, file_path, redownload=redownload)
+
+    return download_dir

process_text.py

@@ -0,0 +1,253 @@
+# pip install sentencex
+from sentencex import segment
+import re
+import uuid
+import os
+LANGUAGE_CODE = {
+    'Akan': 'aka', 'Albanian': 'sq', 'Amharic': 'am', 'Arabic': 'ar', 'Armenian': 'hy',
+    'Assamese': 'as', 'Azerbaijani': 'az', 'Basque': 'eu', 'Bashkir': 'ba', 'Bengali': 'bn',
+    'Bosnian': 'bs', 'Bulgarian': 'bg', 'Burmese': 'my', 'Catalan': 'ca', 'Chinese': 'zh',
+    'Croatian': 'hr', 'Czech': 'cs', 'Danish': 'da', 'Dutch': 'nl', 'English': 'en',
+    'Estonian': 'et', 'Faroese': 'fo', 'Finnish': 'fi', 'French': 'fr', 'Galician': 'gl',
+    'Georgian': 'ka', 'German': 'de', 'Greek': 'el', 'Gujarati': 'gu', 'Haitian Creole': 'ht',
+    'Hausa': 'ha', 'Hebrew': 'he', 'Hindi': 'hi', 'Hungarian': 'hu', 'Icelandic': 'is',
+    'Indonesian': 'id', 'Italian': 'it', 'Japanese': 'ja', 'Kannada': 'kn', 'Kazakh': 'kk',
+    'Korean': 'ko', 'Kurdish': 'ckb', 'Kyrgyz': 'ky', 'Lao': 'lo', 'Lithuanian': 'lt',
+    'Luxembourgish': 'lb', 'Macedonian': 'mk', 'Malay': 'ms', 'Malayalam': 'ml', 'Maltese': 'mt',
+    'Maori': 'mi', 'Marathi': 'mr', 'Mongolian': 'mn', 'Nepali': 'ne', 'Norwegian': 'no',
+    'Norwegian Nynorsk': 'nn', 'Pashto': 'ps', 'Persian': 'fa', 'Polish': 'pl', 'Portuguese': 'pt',
+    'Punjabi': 'pa', 'Romanian': 'ro', 'Russian': 'ru', 'Serbian': 'sr', 'Sinhala': 'si',
+    'Slovak': 'sk', 'Slovenian': 'sl', 'Somali': 'so', 'Spanish': 'es', 'Sundanese': 'su',
+    'Swahili': 'sw', 'Swedish': 'sv', 'Tamil': 'ta', 'Telugu': 'te', 'Thai': 'th',
+    'Turkish': 'tr', 'Ukrainian': 'uk', 'Urdu': 'ur', 'Uzbek': 'uz', 'Vietnamese': 'vi',
+    'Welsh': 'cy', 'Yiddish': 'yi', 'Yoruba': 'yo', 'Zulu': 'zu'
+}
+
+# ==================================================
+# CONSTANTS
+# ==================================================
+
+QUOTE_SPACE = "\uFFFF"  # invisible placeholder for protected quotes
+PUNCT_RE = re.compile(r'[.,;:!?]')
+
+
+# ==================================================
+# CLEAN TEXT (KEEP PUNCTUATION)
+# ==================================================
+
+def clean_text(text):
+    replacements = {
+        "**": "",
+        "*": "",
+        "#": "",
+        "—": "",
+        "“": '"',
+        "”": '"',
+        "‘": "'",
+        "’": "'",
+    }
+    for old, new in replacements.items():
+        text = text.replace(old, new)
+
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+
+# ==================================================
+# PROTECT SHORT QUOTES (ATOMIC QUOTE RULE)
+# ==================================================
+
+def protect_short_quotes(text, max_chars):
+    """
+    If a quoted span fits entirely within max_chars,
+    protect it so it behaves like a single token.
+    """
+    def repl(match):
+        quote = match.group(0)
+        if len(quote) <= max_chars:
+            return quote.replace(" ", QUOTE_SPACE)
+        return quote
+
+    return re.sub(r'"[^"]+"', repl, text)
+
+
+def restore_quotes(text):
+    return text.replace(QUOTE_SPACE, " ")
+
+
+# ==================================================
+# SMART SPLIT FOR LONG SENTENCES (QUOTE AWARE)
+# ==================================================
+
+def smart_split_long_sentence(sentence, max_chars=300, lookback=60):
+    words = re.findall(r'\S+\s*', sentence)
+    chunks = []
+    buffer = ""
+    in_quote = False
+
+    for w in words:
+        tentative = buffer + w
+        quote_count = w.count('"')
+
+        # 1️⃣ SAFE ADD
+        if len(tentative) <= max_chars:
+            buffer = tentative
+            if quote_count % 2 != 0:
+                in_quote = not in_quote
+            continue
+
+        # 2️⃣ OVERFLOW INSIDE QUOTE → MOVE WHOLE QUOTE
+        if in_quote:
+            if buffer.strip():
+                chunks.append(buffer.strip())
+            buffer = w
+            if quote_count % 2 != 0:
+                in_quote = not in_quote
+            continue
+
+        # 3️⃣ NORMAL PUNCTUATION-AWARE REBALANCE
+        split_at = None
+        search_region = buffer[-lookback:]
+
+        matches = list(PUNCT_RE.finditer(search_region))
+        if matches:
+            last = matches[-1]
+            split_at = len(buffer) - lookback + last.end()
+
+        if split_at:
+            chunks.append(buffer[:split_at].strip())
+            buffer = buffer[split_at:].lstrip() + w
+        else:
+            chunks.append(buffer.strip())
+            buffer = w
+
+        if quote_count % 2 != 0:
+            in_quote = not in_quote
+
+    if buffer.strip():
+        chunks.append(buffer.strip())
+
+    return chunks
+
+
+# ==================================================
+# SENTENCE-FIRST CHUNKER
+# ==================================================
+
+def split_into_chunks(text, lang_code="en", max_chars=300):
+    if len(text) <= max_chars:
+        return [text]
+
+    sentences = list(segment(lang_code, text))
+    chunks = []
+    current = ""
+
+    for sen in sentences:
+        sen = sen.strip()
+
+        if len(sen) > max_chars:
+            if current:
+                chunks.append(current.strip())
+                current = ""
+            chunks.extend(smart_split_long_sentence(sen, max_chars))
+            continue
+
+        tentative = f"{current} {sen}".strip() if current else sen
+
+        if len(tentative) <= max_chars:
+            current = tentative
+        else:
+            chunks.append(current.strip())
+            current = sen
+
+    if current.strip():
+        chunks.append(current.strip())
+
+    return chunks
+
+
+# ==================================================
+# FIX DANGLING QUOTES BETWEEN CHUNKS
+# ==================================================
+
+def repair_dangling_quotes(chunks):
+    fixed = []
+
+    for i, chunk in enumerate(chunks):
+        chunk = chunk.strip()
+
+        if i > 0:
+            prev = fixed[-1]
+            if prev.endswith('"') and chunk.startswith('"'):
+                chunk = chunk[1:].lstrip()
+
+        fixed.append(chunk)
+
+    return fixed
+
+
+# ==================================================
+# TTS FILE NAME
+# ==================================================
+
+def get_tts_file_name(text, language="en"):
+    temp_audio_dir = "./ai_tts_voice/"
+    os.makedirs(temp_audio_dir, exist_ok=True)
+
+    clean = re.sub(r'[^a-zA-Z\s]', '', text or "")
+    clean = clean.lower().strip().replace(" ", "_")[:20] or "audio"
+
+    uid = uuid.uuid4().hex[:8].upper()
+    language = language.lower().strip()
+
+    return os.path.join(
+        temp_audio_dir,
+        f"{clean}_{language}_{uid}.wav"
+    )
+
+
+# ==================================================
+# main funtion
+# ==================================================
+
+def text_chunk(text, language="English", char_limit=280):
+    lang_code=LANGUAGE_CODE.get('English',"en")
+
+    # text = clean_text(text) #because Qwen3-TTS can handle that
+
+    # 🔒 Atomic quote protection
+    text = protect_short_quotes(text, char_limit)
+
+    if len(text) > char_limit:
+        print("⚠️ The text is too long. Breaking it into smaller pieces for TTS.")
+
+    chunks = split_into_chunks(text, lang_code, char_limit)
+    chunks = repair_dangling_quotes(chunks)
+
+    # 🔓 Restore spaces inside quotes
+    chunks = [restore_quotes(c) for c in chunks]
+
+    tts_file_name = get_tts_file_name(text, lang_code)
+    return chunks, tts_file_name
+
+
+# ==================================================
+# TEST
+# ==================================================
+
+# from process_text import text_chunk
+# text="Hi, this is a test"
+# chunks, tts_filename =text_chunk(text,  language="English", char_limit=280)
+
+if __name__ == "__main__":
+    text = "He said \"You are a looser\""  # @param {type: "string"}
+
+    language="English"  # @param {type: "string"}
+    char_limit = 20  # @param {type: "number"}
+
+    chunks, filename = text_chunk(text, language, char_limit)
+
+    print(filename)
+    print(len(chunks))
+    for c in chunks:
+        print(len(c), c)

requirements.txt

@@ -0,0 +1,5 @@
+faster-whisper==1.1.1
+ctranslate2==4.5.0
+pysrt
+sentencex
+qwen-tts

subtitle.py

@@ -0,0 +1,574 @@
+
+
+# ==============================================================================
+# --- 1. IMPORTS
+# ==============================================================================
+
+import os
+import re
+import gc
+import uuid
+import math
+import shutil
+import string
+import requests
+import urllib.request
+import urllib.error
+
+import torch
+import pysrt
+from tqdm.auto import tqdm
+from faster_whisper import WhisperModel
+
+
+# ==============================================================================
+# --- 2. CONSTANTS & CONFIGURATION
+# ==============================================================================
+
+# Folder paths for storing generated files and temporary audio
+SUBTITLE_FOLDER = "./generated_subtitle"
+TEMP_FOLDER = "./subtitle_audio"
+
+# Mapping of language names to their ISO 639-1 codes
+LANGUAGE_CODE = {
+    'Akan': 'aka', 'Albanian': 'sq', 'Amharic': 'am', 'Arabic': 'ar', 'Armenian': 'hy',
+    'Assamese': 'as', 'Azerbaijani': 'az', 'Basque': 'eu', 'Bashkir': 'ba', 'Bengali': 'bn',
+    'Bosnian': 'bs', 'Bulgarian': 'bg', 'Burmese': 'my', 'Catalan': 'ca', 'Chinese': 'zh',
+    'Croatian': 'hr', 'Czech': 'cs', 'Danish': 'da', 'Dutch': 'nl', 'English': 'en',
+    'Estonian': 'et', 'Faroese': 'fo', 'Finnish': 'fi', 'French': 'fr', 'Galician': 'gl',
+    'Georgian': 'ka', 'German': 'de', 'Greek': 'el', 'Gujarati': 'gu', 'Haitian Creole': 'ht',
+    'Hausa': 'ha', 'Hebrew': 'he', 'Hindi': 'hi', 'Hungarian': 'hu', 'Icelandic': 'is',
+    'Indonesian': 'id', 'Italian': 'it', 'Japanese': 'ja', 'Kannada': 'kn', 'Kazakh': 'kk',
+    'Korean': 'ko', 'Kurdish': 'ckb', 'Kyrgyz': 'ky', 'Lao': 'lo', 'Lithuanian': 'lt',
+    'Luxembourgish': 'lb', 'Macedonian': 'mk', 'Malay': 'ms', 'Malayalam': 'ml', 'Maltese': 'mt',
+    'Maori': 'mi', 'Marathi': 'mr', 'Mongolian': 'mn', 'Nepali': 'ne', 'Norwegian': 'no',
+    'Norwegian Nynorsk': 'nn', 'Pashto': 'ps', 'Persian': 'fa', 'Polish': 'pl', 'Portuguese': 'pt',
+    'Punjabi': 'pa', 'Romanian': 'ro', 'Russian': 'ru', 'Serbian': 'sr', 'Sinhala': 'si',
+    'Slovak': 'sk', 'Slovenian': 'sl', 'Somali': 'so', 'Spanish': 'es', 'Sundanese': 'su',
+    'Swahili': 'sw', 'Swedish': 'sv', 'Tamil': 'ta', 'Telugu': 'te', 'Thai': 'th',
+    'Turkish': 'tr', 'Ukrainian': 'uk', 'Urdu': 'ur', 'Uzbek': 'uz', 'Vietnamese': 'vi',
+    'Welsh': 'cy', 'Yiddish': 'yi', 'Yoruba': 'yo', 'Zulu': 'zu'
+}
+
+
+# ==============================================================================
+# --- 3. FILE & MODEL DOWNLOADING UTILITIES
+# ==============================================================================
+
+def download_file(url, download_file_path, redownload=False):
+    """Download a single file with urllib and a tqdm progress bar."""
+    base_path = os.path.dirname(download_file_path)
+    os.makedirs(base_path, exist_ok=True)
+
+    if os.path.exists(download_file_path):
+        if redownload:
+            os.remove(download_file_path)
+            tqdm.write(f"♻️ Redownloading: {os.path.basename(download_file_path)}")
+        elif os.path.getsize(download_file_path) > 0:
+            tqdm.write(f"✔️ Skipped (already exists): {os.path.basename(download_file_path)}")
+            return True
+
+    try:
+        request = urllib.request.urlopen(url)
+        total = int(request.headers.get('Content-Length', 0))
+    except urllib.error.URLError as e:
+        print(f"❌ Error: Unable to open URL: {url}")
+        print(f"Reason: {e.reason}")
+        return False
+
+    with tqdm(total=total, desc=os.path.basename(download_file_path), unit='B', unit_scale=True, unit_divisor=1024) as progress:
+        try:
+            urllib.request.urlretrieve(
+                url,
+                download_file_path,
+                reporthook=lambda count, block_size, total_size: progress.update(block_size)
+            )
+        except urllib.error.URLError as e:
+            print(f"❌ Error: Failed to download {url}")
+            print(f"Reason: {e.reason}")
+            return False
+
+    tqdm.write(f"⬇️ Downloaded: {os.path.basename(download_file_path)}")
+    return True
+
+
+def download_model(repo_id, download_folder="./", redownload=False):
+    """
+    Downloads all files from a Hugging Face repository using the public API,
+    avoiding the need for a Hugging Face token for public models.
+    """
+    if not download_folder.strip():
+        download_folder = "."
+
+    api_url = f"https://huggingface.co/api/models/{repo_id}"
+    model_name = repo_id.split('/')[-1]
+    download_dir = os.path.abspath(f"{download_folder.rstrip('/')}/{model_name}")
+    os.makedirs(download_dir, exist_ok=True)
+
+    print(f"📂 Download directory: {download_dir}")
+
+    try:
+        response = requests.get(api_url)
+        response.raise_for_status()
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Error fetching repo info: {e}")
+        return None
+
+    data = response.json()
+    files_to_download = [f["rfilename"] for f in data.get("siblings", [])]
+
+    if not files_to_download:
+        print(f"⚠️ No files found in repo '{repo_id}'.")
+        return None
+
+    print(f"📦 Found {len(files_to_download)} files in repo '{repo_id}'. Checking cache...")
+
+    for file in tqdm(files_to_download, desc="Processing files", unit="file"):
+        file_url = f"https://huggingface.co/{repo_id}/resolve/main/{file}"
+        file_path = os.path.join(download_dir, file)
+        download_file(file_url, file_path, redownload=redownload)
+
+    return download_dir
+
+
+# ==============================================================================
+# --- 4. CORE TRANSCRIPTION & PROCESSING LOGIC
+# ==============================================================================
+
+def get_language_name(code):
+    """Retrieves the full language name from its code."""
+    for name, value in LANGUAGE_CODE.items():
+        if value == code:
+            return name
+    return None
+
+def clean_file_name(file_path):
+    """Generates a clean, unique file name to avoid path issues."""
+    dir_name = os.path.dirname(file_path)
+    base_name, extension = os.path.splitext(os.path.basename(file_path))
+
+    cleaned_base = re.sub(r'[^a-zA-Z\d]+', '_', base_name)
+    cleaned_base = re.sub(r'_+', '_', cleaned_base).strip('_')
+    random_uuid = uuid.uuid4().hex[:6]
+
+    return os.path.join(dir_name, f"{cleaned_base}_{random_uuid}{extension}")
+
+def format_segments(segments):
+    """Formats the raw segments from Whisper into structured lists."""
+    sentence_timestamp = []
+    words_timestamp = []
+    speech_to_text = ""
+
+    for i in segments:
+        text = i.text.strip()
+        sentence_id = len(sentence_timestamp)
+        sentence_timestamp.append({
+            "id": sentence_id,
+            "text": text,
+            "start": i.start,
+            "end": i.end,
+            "words": []
+        })
+        speech_to_text += text + " "
+
+        for word in i.words:
+            word_data = {
+                "word": word.word.strip(),
+                "start": word.start,
+                "end": word.end
+            }
+            sentence_timestamp[sentence_id]["words"].append(word_data)
+            words_timestamp.append(word_data)
+
+    return sentence_timestamp, words_timestamp, speech_to_text.strip()
+
+# def get_audio_file(uploaded_file):
+#     """Copies the uploaded media file to a temporary location for processing."""
+#     temp_path = os.path.join(TEMP_FOLDER, os.path.basename(uploaded_file))
+#     cleaned_path = clean_file_name(temp_path)
+#     shutil.copy(uploaded_file, cleaned_path)
+#     return cleaned_path
+
+whisper_model=None
+
+def load_whisper_model(model_name="deepdml/faster-whisper-large-v3-turbo-ct2"):
+  global whisper_model
+  if whisper_model is None:
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    compute_type = "float16" if torch.cuda.is_available() else "int8"
+    try:
+      whisper_model = WhisperModel(
+                      model_name,
+                      device=device,
+                      compute_type=compute_type,
+                  )
+    except Exception as e:
+      model_dir = download_model(
+                  "deepdml/faster-whisper-large-v3-turbo-ct2",
+                  download_folder="./",
+                  redownload=False)
+      whisper_model = WhisperModel(
+                  model_dir,
+                  device=device,
+                  compute_type=compute_type)
+  return whisper_model
+
+
+def whisper_subtitle(uploaded_file, source_language):
+    """
+    Main transcription function. Loads the model, transcribes the audio,
+    and generates subtitle files.
+    """
+
+    model = load_whisper_model()
+
+
+    # 2. Process audio file
+    # audio_file_path = get_audio_file(uploaded_file)
+    audio_file_path=uploaded_file
+
+    # 3. Transcribe
+    detected_language = source_language
+    if source_language == "Auto":
+        segments, info = model.transcribe(audio_file_path, word_timestamps=True)
+        detected_lang_code = info.language
+        detected_language = get_language_name(detected_lang_code)
+    else:
+        lang_code = LANGUAGE_CODE[source_language]
+        segments, _ = model.transcribe(audio_file_path, word_timestamps=True, language=lang_code)
+
+    sentence_timestamps, word_timestamps, transcript_text = format_segments(segments)
+
+    # 4. Cleanup
+    # if os.path.exists(audio_file_path):
+    #     os.remove(audio_file_path)
+    del model
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+    # 5. Prepare output file paths
+    base_filename = os.path.splitext(os.path.basename(uploaded_file))[0][:30]
+    srt_base = f"{SUBTITLE_FOLDER}/{base_filename}_{detected_language}.srt"
+    clean_srt_path = clean_file_name(srt_base)
+    txt_path = clean_srt_path.replace(".srt", ".txt")
+    word_srt_path = clean_srt_path.replace(".srt", "_word_level.srt")
+    custom_srt_path = clean_srt_path.replace(".srt", "_Multiline.srt")
+    shorts_srt_path = clean_srt_path.replace(".srt", "_shorts.srt")
+
+    # 6. Generate all subtitle files
+    generate_srt_from_sentences(sentence_timestamps, srt_path=clean_srt_path)
+    word_level_srt(word_timestamps, srt_path=word_srt_path)
+    shorts_json=write_sentence_srt(
+        word_timestamps, output_file=shorts_srt_path, max_lines=1,
+        max_duration_s=2.0, max_chars_per_line=17
+    )
+    sentence_json=write_sentence_srt(
+        word_timestamps, output_file=custom_srt_path, max_lines=2,
+        max_duration_s=7.0, max_chars_per_line=38
+    )
+
+    with open(txt_path, 'w', encoding='utf-8') as f:
+        f.write(transcript_text)
+
+    return (
+        clean_srt_path, custom_srt_path, word_srt_path, shorts_srt_path,
+        txt_path, transcript_text, sentence_json,shorts_json,detected_language
+    )
+
+
+# ==============================================================================
+# --- 5. SUBTITLE GENERATION & FORMATTING
+# ==============================================================================
+
+def convert_time_to_srt_format(seconds):
+    """Converts seconds to the standard SRT time format (HH:MM:SS,ms)."""
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = int(seconds % 60)
+    milliseconds = round((seconds - int(seconds)) * 1000)
+
+    if milliseconds == 1000:
+        milliseconds = 0
+        secs += 1
+        if secs == 60:
+            secs, minutes = 0, minutes + 1
+            if minutes == 60:
+                minutes, hours = 0, hours + 1
+
+    return f"{hours:02}:{minutes:02}:{secs:02},{milliseconds:03}"
+
+def split_line_by_char_limit(text, max_chars_per_line=38):
+    """Splits a string into multiple lines based on a character limit."""
+    words = text.split()
+    lines = []
+    current_line = ""
+    for word in words:
+        if not current_line:
+            current_line = word
+        elif len(current_line + " " + word) <= max_chars_per_line:
+            current_line += " " + word
+        else:
+            lines.append(current_line)
+            current_line = word
+    if current_line:
+        lines.append(current_line)
+    return lines
+
+def merge_punctuation_glitches(subtitles):
+    """Cleans up punctuation artifacts at the boundaries of subtitle entries."""
+    if not subtitles:
+        return []
+
+    cleaned = [subtitles[0]]
+    for i in range(1, len(subtitles)):
+        prev = cleaned[-1]
+        curr = subtitles[i]
+
+        prev_text = prev["text"].rstrip()
+        curr_text = curr["text"].lstrip()
+
+        match = re.match(r'^([,.:;!?]+)(\s*)(.+)', curr_text)
+        if match:
+            punct, _, rest = match.groups()
+            if not prev_text.endswith(tuple(punct)):
+                prev["text"] = prev_text + punct
+            curr_text = rest.strip()
+
+        unwanted_chars = ['"', '“', '”', ';', ':']
+        for ch in unwanted_chars:
+            curr_text = curr_text.replace(ch, '')
+        curr_text = curr_text.strip()
+
+        if not curr_text or re.fullmatch(r'[.,!?]+', curr_text):
+            prev["end"] = curr["end"]
+            continue
+
+        curr["text"] = curr_text
+        prev["text"] = prev["text"].replace('"', '').replace('“', '').replace('”', '')
+        cleaned.append(curr)
+
+    return cleaned
+
+import json
+def write_sentence_srt(
+    word_level_timestamps, output_file="subtitles_professional.srt", max_lines=2,
+    max_duration_s=7.0, max_chars_per_line=38, hard_pause_threshold=0.5,
+    merge_pause_threshold=0.4
+):
+    """Creates professional-grade SRT files and a corresponding timestamp.json file."""
+    if not word_level_timestamps:
+        return
+
+    # Phase 1: Generate draft subtitles based on timing and length rules
+    draft_subtitles = []
+    i = 0
+    while i < len(word_level_timestamps):
+        start_time = word_level_timestamps[i]["start"]
+        
+        # We'll now store the full word objects, not just the text
+        current_word_objects = []
+        
+        j = i
+        while j < len(word_level_timestamps):
+            entry = word_level_timestamps[j]
+            
+            # Create potential text from the word objects
+            potential_words = [w["word"] for w in current_word_objects] + [entry["word"]]
+            potential_text = " ".join(potential_words)
+
+            if len(split_line_by_char_limit(potential_text, max_chars_per_line)) > max_lines: break
+            if (entry["end"] - start_time) > max_duration_s and current_word_objects: break
+
+            if j > i:
+                prev_entry = word_level_timestamps[j-1]
+                pause = entry["start"] - prev_entry["end"]
+                if pause >= hard_pause_threshold: break
+                if prev_entry["word"].endswith(('.','!','?')): break
+
+            # Append the full word object
+            current_word_objects.append(entry)
+            j += 1
+
+        if not current_word_objects:
+            current_word_objects.append(word_level_timestamps[i])
+            j = i + 1
+
+        text = " ".join([w["word"] for w in current_word_objects])
+        end_time = word_level_timestamps[j - 1]["end"]
+        
+        # Include the list of word objects in our draft subtitle
+        draft_subtitles.append({
+            "start": start_time,
+            "end": end_time,
+            "text": text,
+            "words": current_word_objects
+        })
+        i = j
+
+    # Phase 2: Post-process to merge single-word "orphan" subtitles
+    if not draft_subtitles: return
+    final_subtitles = [draft_subtitles[0]]
+    for k in range(1, len(draft_subtitles)):
+        prev_sub = final_subtitles[-1]
+        current_sub = draft_subtitles[k]
+        is_orphan = len(current_sub["text"].split()) == 1
+        pause_from_prev = current_sub["start"] - prev_sub["end"]
+
+        if is_orphan and pause_from_prev < merge_pause_threshold:
+            merged_text = prev_sub["text"] + " " + current_sub["text"]
+            if len(split_line_by_char_limit(merged_text, max_chars_per_line)) <= max_lines:
+                prev_sub["text"] = merged_text
+                prev_sub["end"] = current_sub["end"]
+                
+                # Merge the word-level data as well
+                prev_sub["words"].extend(current_sub["words"])
+                continue
+
+        final_subtitles.append(current_sub)
+
+    final_subtitles = merge_punctuation_glitches(final_subtitles)
+    # print(final_subtitles)
+    # ==============================================================================
+    # NEW CODE BLOCK: Generate JSON data and write files
+    # ==============================================================================
+    
+    # This dictionary will hold the data for our JSON file
+    timestamps_data = {}
+    
+    # Phase 3: Write the final SRT file (and prepare JSON data)
+    with open(output_file, "w", encoding="utf-8") as f:
+        for idx, sub in enumerate(final_subtitles, start=1):
+            # --- SRT Writing (Unchanged) ---
+            text = sub["text"].replace(" ,", ",").replace(" .", ".")
+            formatted_lines = split_line_by_char_limit(text, max_chars_per_line)
+            start_time_str = convert_time_to_srt_format(sub['start'])
+            end_time_str = convert_time_to_srt_format(sub['end'])
+            
+            f.write(f"{idx}\n")
+            f.write(f"{start_time_str} --> {end_time_str}\n")
+            f.write("\n".join(formatted_lines) + "\n\n")
+            
+            # --- JSON Data Population (New) ---
+            # Create the list of word dictionaries for the current subtitle
+            word_data = []
+            for word_obj in sub["words"]:
+                word_data.append({
+                    "word": word_obj["word"],
+                    "start": convert_time_to_srt_format(word_obj["start"]),
+                    "end": convert_time_to_srt_format(word_obj["end"])
+                })
+            
+            # Add the complete entry to our main dictionary
+            timestamps_data[str(idx)] = {
+                "text": "\n".join(formatted_lines),
+                "start": start_time_str,
+                "end": end_time_str,
+                "words": word_data
+            }
+
+    # Write the collected data to the JSON file
+    json_output_file = output_file.replace(".srt",".json")
+    with open(json_output_file, "w", encoding="utf-8") as f_json:
+        json.dump(timestamps_data, f_json, indent=4, ensure_ascii=False)
+        
+    # print(f"Successfully generated SRT file: {output_file}")
+    # print(f"Successfully generated JSON file: {json_output_file}")
+    return json_output_file
+
+def write_subtitles_to_file(subtitles, filename="subtitles.srt"):
+    """Writes a dictionary of subtitles to a standard SRT file."""
+    with open(filename, 'w', encoding='utf-8') as f:
+        for id, entry in subtitles.items():
+            if entry['start'] is None or entry['end'] is None:
+                print(f"Skipping subtitle ID {id} due to missing timestamps.")
+                continue
+            start_time = convert_time_to_srt_format(entry['start'])
+            end_time = convert_time_to_srt_format(entry['end'])
+            f.write(f"{id}\n")
+            f.write(f"{start_time} --> {end_time}\n")
+            f.write(f"{entry['text']}\n\n")
+
+def word_level_srt(words_timestamp, srt_path="word_level_subtitle.srt", shorts=False):
+    """Generates an SRT file with one word per subtitle entry."""
+    punctuation = re.compile(r'[.,!?;:"\–—_~^+*|]')
+    with open(srt_path, 'w', encoding='utf-8') as srt_file:
+        for i, word_info in enumerate(words_timestamp, start=1):
+            start = convert_time_to_srt_format(word_info['start'])
+            end = convert_time_to_srt_format(word_info['end'])
+            word = re.sub(punctuation, '', word_info['word'])
+            if word.strip().lower() == 'i': word = "I"
+            if not shorts: word = word.replace("-", "")
+            srt_file.write(f"{i}\n{start} --> {end}\n{word}\n\n")
+
+def generate_srt_from_sentences(sentence_timestamp, srt_path="default_subtitle.srt"):
+    """Generates a standard SRT file from sentence-level timestamps."""
+    with open(srt_path, 'w', encoding='utf-8') as srt_file:
+        for index, sentence in enumerate(sentence_timestamp, start=1):
+            start = convert_time_to_srt_format(sentence['start'])
+            end = convert_time_to_srt_format(sentence['end'])
+            srt_file.write(f"{index}\n{start} --> {end}\n{sentence['text']}\n\n")
+
+
+
+
+# ==============================================================================
+# --- 7. MAIN ORCHESTRATOR FUNCTION
+# ==============================================================================
+
+def subtitle_maker(media_file, source_lang):
+    """
+    The main entry point to generate and optionally translate subtitles.
+
+    Args:
+        media_file (str): Path to the input media file.
+        source_lang (str): The source language ('Automatic' for detection).
+        target_lang (str): The target language for translation.
+
+    Returns:
+        A tuple containing paths to all generated files and the transcript text.
+    """
+
+    try:
+        (
+            default_srt, custom_srt, word_srt, shorts_srt,
+            txt_path, transcript, sentence_json,word_json,detected_lang
+        ) = whisper_subtitle(media_file, source_lang)
+    except Exception as e:
+        print(f"❌ An error occurred during transcription: {e}")
+        return (None, None, None, None, None, None,None,None, f"Error: {e}")
+
+    
+    return (
+        default_srt, custom_srt, word_srt,
+        shorts_srt, txt_path,sentence_json,word_json, transcript,detected_lang
+    )
+
+
+# ==============================================================================
+# --- 8. INITIALIZATION
+# ==============================================================================
+os.makedirs(SUBTITLE_FOLDER, exist_ok=True)
+os.makedirs(TEMP_FOLDER, exist_ok=True)
+
+
+# from subtitle import subtitle_maker
+# media_file = "/content/output.mp3"
+# source_lang = "Auto" #"English"
+
+# default_srt, custom_srt, word_srt,shorts_srt, txt_path,sentence_json,word_json, transcript,detected_lang= subtitle_maker(
+#     media_file, source_lang
+# )
+
+
+# default_srt      -> Original subtitles generated directly by Whisper-Large-V3-Turbo-CT2
+# custom_srt       -> Modified version of default subtitles with shorter segments 
+#                      (better readability for horizontal videos, Maximum 38 characters per segment. )
+# word_srt         -> Word-level timestamps (useful for creating YouTube Shorts/Reels)
+# shorts_srt       -> Optimized subtitles for vertical videos (displays 3–4 words at a time , Maximum 17 characters per segment.)
+# txt_path         -> Full transcript as plain text (useful for video summarization or for asking questions about the video or audio data with other LLM tools)
+# sentence_json,word_json --> To Generate .ass file later
+# transcript       -> Transcript text directly returned by the function, if you just need the transcript
+# detected_lang    -> Detected Lang
+# All functionality is contained in a single file, making it portable 
+# and reusable across multiple projects for different purposes.