Update app.py

app.py

@@ -3,21 +3,16 @@ import re
 import asyncio
 import tempfile
 import logging
+import subprocess
 import threading
-import time
-import shutil
+from pathlib import Path
 
 import gradio as gr
 import edge_tts
-from pydub import AudioSegment
 
-
-# ==================================================
-# CONFIGURATION
-# ==================================================
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("MyanmarEdgeTTS")
+# =========================================================
+# APP CONFIG
+# =========================================================
 
 APP_TITLE = "Myanmar Multilingual TTS Studio"
 
@@ -28,1227 +23,805 @@ MIN_AUDIO_BYTES = 100
 
 DEFAULT_VOICE_ID = "it-IT-GiuseppeMultilingualNeural"
 
-OUTPUT_DIR = os.path.join(
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+
+logger = logging.getLogger("MyanmarTTS")
+
+JOB_SEMAPHORE = threading.Semaphore(MAX_CONCURRENT_JOBS)
+
+WORK_DIR = os.path.join(
     tempfile.gettempdir(),
     "myanmar_multilingual_tts",
 )
 
-os.makedirs(OUTPUT_DIR, exist_ok=True)
-
+os.makedirs(WORK_DIR, exist_ok=True)
 
-# ==================================================
-# VOICE DISPLAY NAMES
-# ==================================================
 
-PINNED_VOICES = {
-    "my-MM-NilarNeural",
-    "my-MM-ThihaNeural",
-    "it-IT-GiuseppeMultilingualNeural",
-}
+# =========================================================
+# VOICE ALIASES
+# UI မှာ မူရင်း English Voice ID မပြဘဲ မြန်မာအမည်သာပြမည်။
+# =========================================================
 
-VOICE_DISPLAY_NAMES = {
+VOICE_ALIASES = {
     "it-IT-GiuseppeMultilingualNeural": "နေတိုး",
     "my-MM-NilarNeural": "ဝတ်မှုန်ရွှေရည်",
     "my-MM-ThihaNeural": "ပြေတီဦး",
 }
 
-VOICE_ALIAS_NAMES = [
-    "အကယ်ဒမီမင်းမော်ကွန်း",
-    "ပိုင်တံခွန်",
-    "ရဲတိုက်",
-    "မြင့်မြတ်",
-    "နေမင်း",
-    "အောင်ရဲလင်း",
-    "ကျော်ကျော်ဗို",
-    "လွင်မိုး",
-    "ပြေတီဦး",
-    "နေတိုး",
-    "ဝတ်မှုန်ရွှေရည်",
-    "ဖွေးဖွေး",
-    "အိန္ဒြာကျော်ဇင်",
-    "သက်မွန်မြင့်",
-    "မိုးဟေကို",
-    "ရွှေမှုံရတီ",
-    "သင်ဇာဝင့်ကျော်",
-    "ပိုင်ဖြိုးသု",
-    "ခင်ဝင့်ဝါ",
-    "အေးမြတ်သူ",
-    "အိချောပို",
-    "နန်းဆုဦး",
-    "အေးဝတ်ရည်သောင်း",
-    "ဆုပန်ထွာ",
-    "မေမြင့်မိုရ်",
-    "ဝါဆိုမိုးဦး",
-    "သံသာမိုးသိမ့်",
-    "မြတ်နိုးအေး",
-    "ခင်သဇင်",
-    "ယွန်းယွန်း",
-    "မင်းဦး",
-    "ခန့်စည်သူ",
-    "ထွန်းထွန်း",
-    "ဒေါင်း",
-    "အောင်လေး",
-    "ဇေရဲထက်",
-    "ဟိန်းဝေယံ",
-    "မင်းရာဇာ",
-    "ရဲအောင်",
-    "ကျော်ဟိန်း",
-    "ဇင်ဝိုင်း",
-    "လူမင်း",
-    "ခိုင်သင်းကြည်",
-    "စိုးမြတ်သူဇာ",
-    "ထက်ထက်မိုးဦး",
-    "မေသန်းနု",
-    "နန္ဒာလှိုင်",
-    "စိုးပြည့်သဇင်",
-    "ဝိုင်းစုခိုင်သိန်း",
-    "ချစ်သုဝေ",
-    "မေကဗျာ",
-    "မိုးပြည့်ပြည့်မောင်",
-    "ယုသန္တာတင်",
-    "သဲစုညိမ်း",
-    "မေသက်ခိုင်",
-    "ရွှေသမီး",
-    "စန္ဒီမြင့်လွင်",
-    "နန်းမြတ်ဖြိုးသင်း",
-    "အဆိုတော်အမျိုးသား",
-    "အဆိုတော်အမျိုးသမီး",
-]
-
-
-VOICE_CACHE = []
-VOICE_CACHE_TIME = 0
-VOICE_CACHE_TTL = 3600
-
-VOICE_LOCK = threading.Lock()
-
-JOB_SEMAPHORE = threading.Semaphore(
-    MAX_CONCURRENT_JOBS
-)
-
-
-# ==================================================
-# VOICE MANAGEMENT
-# ==================================================
-
-async def fetch_voices_async():
-    return await edge_tts.list_voices()
-
-
-def get_fallback_voices():
-    return [
-        {
-            "ShortName": "my-MM-NilarNeural",
-            "FriendlyName": "Nilar",
-            "Gender": "Female",
-            "Locale": "my-MM",
-        },
-        {
-            "ShortName": "my-MM-ThihaNeural",
-            "FriendlyName": "Thiha",
-            "Gender": "Male",
-            "Locale": "my-MM",
-        },
-        {
-            "ShortName": "it-IT-GiuseppeMultilingualNeural",
-            "FriendlyName": "Giuseppe Multilingual",
-            "Gender": "Male",
-            "Locale": "it-IT",
-        },
-    ]
-
-
-def get_voices(force_refresh=False):
-    global VOICE_CACHE
-    global VOICE_CACHE_TIME
-
-    now = time.time()
-
-    with VOICE_LOCK:
-
-        if (
-            VOICE_CACHE
-            and not force_refresh
-            and now - VOICE_CACHE_TIME < VOICE_CACHE_TTL
-        ):
-            return VOICE_CACHE
-
-        try:
-            voices = asyncio.run(
-                fetch_voices_async()
-            )
-
-            selected = []
+VOICE_LIST_CACHE = []
+VOICE_ID_TO_LABEL = {}
+VOICE_LABEL_TO_ID = {}
 
-            for voice in voices:
 
-                short_name = voice.get(
-                    "ShortName",
-                    "",
-                )
-
-                if not short_name:
-                    continue
-
-                is_pinned = (
-                    short_name in PINNED_VOICES
-                )
-
-                is_multilingual = (
-                    "MultilingualNeural" in short_name
-                )
-
-                if is_pinned or is_multilingual:
-                    selected.append(voice)
-
-            available_ids = {
-                voice["ShortName"]
-                for voice in selected
-            }
-
-            fallback_map = {
-                voice["ShortName"]: voice
-                for voice in get_fallback_voices()
-            }
-
-            for short_name in PINNED_VOICES:
-
-                if short_name not in available_ids:
-
-                    selected.append(
-                        fallback_map[short_name]
-                    )
-
-            # Default Voice ကို အပေါ်ဆုံးထားမယ်။
-            selected.sort(
-                key=lambda voice: (
-                    0
-                    if voice["ShortName"] == DEFAULT_VOICE_ID
-                    else 1
-                    if voice["ShortName"] in PINNED_VOICES
-                    else 2,
-                    voice.get("Locale", ""),
-                    voice.get("ShortName", ""),
-                )
-            )
-
-            VOICE_CACHE = selected
-            VOICE_CACHE_TIME = now
+# =========================================================
+# TEXT CLEANING
+# မူရင်းစာသားနှင့် မြန်မာစာလုံးများကို မဖျက်ပါ။
+# Invisible/control characters များကိုသာ ရှင်းမည်။
+# =========================================================
 
-            logger.info(
-                "Loaded %d selected voices",
-                len(VOICE_CACHE),
-            )
-
-            return VOICE_CACHE
+def clean_text(text):
+    if not text:
+        return ""
 
-        except Exception:
+    text = str(text)
 
-            logger.exception(
-                "Unable to retrieve Edge TTS voices"
-            )
+    # Unicode normalization မလုပ်ဘဲ control characters သာဖယ်ရှား
+    text = text.replace("\ufeff", "")
+    text = text.replace("\u200b", "")
+    text = text.replace("\u200c", "")
+    text = text.replace("\u200d", "")
+    text = text.replace("\u2060", "")
+    text = text.replace("\r\n", "\n")
+    text = text.replace("\r", "\n")
 
-            if VOICE_CACHE:
-                return VOICE_CACHE
+    # Tab များကို space အဖြစ်ပြောင်း
+    text = text.replace("\t", " ")
 
-            VOICE_CACHE = get_fallback_voices()
-            VOICE_CACHE_TIME = now
+    # Control characters များကို ဖယ်ရှားသော်လည်း newline ကိုထိန်းထား
+    text = "".join(
+        ch for ch in text
+        if ch == "\n" or ch == "\u200b" or ord(ch) >= 32
+    )
 
-            return VOICE_CACHE
+    # အပို space များကိုရှင်း
+    text = re.sub(r"[ ]+", " ", text)
+    text = re.sub(r" *\n *", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
 
+    return text.strip()
 
-def build_voice_display_map():
-    """
-    Create Myanmar display names for all selected voices.
-    Original Voice IDs are not displayed in the UI.
-    """
 
-    voices = get_voices()
+# =========================================================
+# VOICE LIST
+# =========================================================
 
-    result = {}
-    used_names = set()
+async def fetch_voices():
+    voices = await edge_tts.list_voices()
 
-    alias_index = 0
+    selected = []
 
     for voice in voices:
-
-        short_name = voice.get(
-            "ShortName",
-            "",
-        )
+        short_name = voice.get("ShortName", "")
 
         if not short_name:
             continue
 
-        if short_name in VOICE_DISPLAY_NAMES:
-
-            label = VOICE_DISPLAY_NAMES[
-                short_name
-            ]
-
-        else:
-
-            label = None
-
-            while alias_index < len(VOICE_ALIAS_NAMES):
-
-                candidate = VOICE_ALIAS_NAMES[
-                    alias_index
-                ]
-
-                alias_index += 1
-
-                if candidate not in used_names:
-                    label = candidate
-                    break
-
-            if label is None:
-
-                label = (
-                    f"အသံဇာတ်ကောင် "
-                    f"{len(result) + 1}"
-                )
-
-        base_label = label
-        suffix = 2
-
-        while label in used_names:
-
-            label = f"{base_label} {suffix}"
-            suffix += 1
-
-        used_names.add(label)
-
-        result[label] = short_name
-
-    return result
-
-
-def voice_label(voice):
-    short_name = voice.get(
-        "ShortName",
-        "",
-    )
-
-    return VOICE_DISPLAY_NAMES.get(
-        short_name,
-        "",
-    )
-
-
-def get_voice_map():
-    return build_voice_display_map()
+        # လိုအပ်သော မြန်မာအသံများကို အမြဲထည့်ထားမည်။
+        if short_name in VOICE_ALIASES:
+            selected.append(voice)
+            continue
 
+        # Multilingual Neural အသံများကိုလည်း ထည့်မည်။
+        if "MultilingualNeural" in short_name:
+            selected.append(voice)
 
-def get_voice_choices():
-    return list(
-        get_voice_map().keys()
-    )
+    # ShortName အလိုက် duplicate မဖြစ်စေရန်
+    unique = {}
+    for voice in selected:
+        unique[voice["ShortName"]] = voice
 
+    selected = list(unique.values())
 
-def get_default_voice_label():
+    # သတ်မှတ်ထားသော Voice များကို အပေါ်ဆုံးထားမည်။
+    pinned_order = [
+        "it-IT-GiuseppeMultilingualNeural",
+        "my-MM-NilarNeural",
+        "my-MM-ThihaNeural",
+    ]
 
-    voice_map = get_voice_map()
+    def sort_key(voice):
+        name = voice.get("ShortName", "")
+        if name in pinned_order:
+            return (0, pinned_order.index(name))
+        return (1, name.lower())
 
-    for label, voice_id in voice_map.items():
+    selected.sort(key=sort_key)
 
-        if voice_id == DEFAULT_VOICE_ID:
-            return label
+    return selected
 
-    return next(
-        iter(voice_map),
-        None,
-    )
 
+def get_voice_label(voice_id, index=0):
+    if voice_id in VOICE_ALIASES:
+        return VOICE_ALIASES[voice_id]
 
-def refresh_voices():
+    # အခြား Voice များကိုလည်း English ID မပြဘဲ အမည်ပေးမည်။
+    return f"အခြားအသံ {index + 1:03d}"
 
-    get_voices(
-        force_refresh=True
-    )
 
-    choices = get_voice_choices()
+def load_voice_choices():
+    global VOICE_LIST_CACHE
+    global VOICE_ID_TO_LABEL
+    global VOICE_LABEL_TO_ID
 
-    default_label = get_default_voice_label()
+    try:
+        voices = asyncio.run(fetch_voices())
 
-    return (
-        gr.update(
-            choices=choices,
-            value=default_label,
-        ),
-        (
-            "Voice List ပြန်ရယူပြီးပါပြီ။ "
-            f"Voice {len(choices)} ခု ရရှိထားသည်။"
-        ),
-    )
+        VOICE_LIST_CACHE = voices
+        VOICE_ID_TO_LABEL = {}
+        VOICE_LABEL_TO_ID = {}
 
+        choices = []
 
-# ==================================================
-# SCRIPT PROCESSING
-# ==================================================
+        for index, voice in enumerate(voices):
+            voice_id = voice.get("ShortName", "")
 
-def normalize_script(text):
-    """
-    Normalize whitespace without changing word order.
-    """
+            if not voice_id:
+                continue
 
-    text = (text or "").replace(
-        "\r\n",
-        "\n",
-    ).replace(
-        "\r",
-        "\n",
-    )
+            label = get_voice_label(voice_id, index)
 
-    lines = []
+            # Dropdown မှာ duplicate label မဖြစ်စေရန်
+            if label in VOICE_LABEL_TO_ID:
+                label = f"{label} ({index + 1})"
 
-    for line in text.split("\n"):
+            VOICE_ID_TO_LABEL[voice_id] = label
+            VOICE_LABEL_TO_ID[label] = voice_id
+            choices.append(label)
 
-        line = re.sub(
-            r"[ \t]+",
-            " ",
-            line,
-        ).strip()
+        if not choices:
+            raise RuntimeError("Voice list is empty.")
 
-        if line:
-            lines.append(line)
+        return choices
 
-    return "\n".join(lines)
+    except Exception as exc:
+        logger.exception("Voice list loading failed: %s", exc)
 
+        fallback = [
+            "နေတိုး",
+            "ဝတ်မှုန်ရွှေရည်",
+            "ပြေတီဦး",
+        ]
 
-def split_into_sentences(text):
-    """
-    Split at sentence boundaries where possible.
-    """
+        VOICE_LABEL_TO_ID = {
+            "နေတိုး": "it-IT-GiuseppeMultilingualNeural",
+            "ဝတ်မှုန်ရွှေရည်": "my-MM-NilarNeural",
+            "ပြေတီဦး": "my-MM-ThihaNeural",
+        }
 
-    parts = re.split(
-        r"(?<=[.!?။！？၊])\s+",
-        text,
-    )
+        VOICE_ID_TO_LABEL = {
+            value: key
+            for key, value in VOICE_LABEL_TO_ID.items()
+        }
 
-    return [
-        part.strip()
-        for part in parts
-        if part.strip()
-    ]
+        return fallback
 
 
-def split_long_text(
-    text,
-    max_chars=MAX_CHUNK_CHARACTERS,
-):
-    """
-    Safety fallback for a long section that has no
-    usable Myanmar sentence-ending punctuation.
-    Split at whitespace without dropping words.
-    """
+# =========================================================
+# TEXT CHUNKING
+# Myanmar sentence endings ကို ဦးစားပေးခွဲမည်။
+# စာသားအစဉ်နှင့် စာသားအပြည့်အစုံကို ထိန်းထားမည်။
+# =========================================================
 
-    words = text.split()
+def split_long_text(text, max_chars=MAX_CHUNK_CHARACTERS):
+    text = text.strip()
 
-    chunks = []
-    current_words = []
-    current_length = 0
-
-    for word in words:
+    if not text:
+        return []
 
-        added_length = len(word)
+    if len(text) <= max_chars:
+        return [text]
 
-        if current_words:
-            added_length += 1
+    result = []
+    remaining = text
 
-        if (
-            current_words
-            and current_length + added_length > max_chars
-        ):
+    while len(remaining) > max_chars:
+        section = remaining[:max_chars]
 
-            chunks.append(
-                " ".join(current_words)
-            )
+        # မြန်မာဝါကျအဆုံးကို ဦးစားပေးရှာ
+        candidates = [
+            section.rfind("။"),
+            section.rfind("!"),
+            section.rfind("?"),
+            section.rfind("၊"),
+            section.rfind("."),
+            section.rfind("\n"),
+        ]
 
-            current_words = [word]
-            current_length = len(word)
+        split_at = max(candidates)
 
-        else:
+        # အလွန်တိုသော chunk မဖြစ်စေရန်
+        if split_at < max_chars * 0.45:
+            split_at = section.rfind(" ")
 
-            current_words.append(word)
-            current_length += added_length
+        if split_at < max_chars * 0.35:
+            split_at = max_chars
 
-    if current_words:
+        # Sentence punctuation ကို မဖယ်ရှားဘဲ ခွဲမည်
+        if split_at < len(remaining):
+            split_at += 1
 
-        chunks.append(
-            " ".join(current_words)
-        )
+        part = remaining[:split_at].strip()
 
-    return chunks
+        if part:
+            result.append(part)
 
+        remaining = remaining[split_at:].strip()
 
-def split_for_tts(text):
-    """
-    Split TTS text around 1800 characters.
+    if remaining:
+        result.append(remaining)
 
-    Prefer Myanmar sentence-ending punctuation '။'.
-    Preserve punctuation and text order.
+    return result
 
-    If a section has no '။' punctuation available,
-    use whitespace as a safety fallback.
-    """
 
-    text = (text or "").strip()
+def split_text_for_tts(text):
+    text = clean_text(text)
 
     if not text:
         return []
 
-    chunks = []
-
-    # '။' နောက်မှာပဲ အဓိကခွဲမယ်။
-    # Lookbehind သုံးထားတာကြောင့် '။' မပျောက်ပါ။
-    sentences = re.split(
-        r"(?<=။)",
+    # Myanmar sentence end၊ English punctuation နှင့် newline
+    # များကို အခြေခံပြီး စာသားအပိုင်းများ စုမည်။
+    units = re.split(
+        r"(?<=[။.!?၊,:;])\s+|\n+",
         text,
     )
 
+    chunks = []
     current = ""
 
-    for sentence in sentences:
+    for unit in units:
+        unit = unit.strip()
 
-        sentence = sentence.strip()
-
-        if not sentence:
+        if not unit:
             continue
 
-        candidate = (
-            current + " " + sentence
-        ).strip()
+        # ဝါကျတစ်ကြောင်းတည်းက limit ထက်ရှည်လျှင် ထပ်ခွဲမည်။
+        if len(unit) > MAX_CHUNK_CHARACTERS:
+            if current:
+                chunks.append(current)
+                current = ""
 
-        if (
-            current
-            and len(candidate) > MAX_CHUNK_CHARACTERS
-        ):
+            chunks.extend(
+                split_long_text(unit, MAX_CHUNK_CHARACTERS)
+            )
+            continue
 
-            chunks.append(current)
+        if not current:
+            current = unit
+            continue
 
-            current = sentence
+        combined = current + " " + unit
 
+        if len(combined) <= MAX_CHUNK_CHARACTERS:
+            current = combined
         else:
-
-            current = candidate
+            chunks.append(current)
+            current = unit
 
     if current:
         chunks.append(current)
 
-    final_chunks = []
-
-    for chunk in chunks:
-
-        chunk = chunk.strip()
-
-        if not chunk:
-            continue
-
-        # ပုဒ်ချမရှိဘဲ အပိုင်းအလွန်ရှည်နေရင်
-        # Edge TTS error မဖြစ်အောင် whitespace ဖြင့်
-        # safety fallback ခွဲမယ်။
-        if len(chunk) > MAX_CHUNK_CHARACTERS:
-
-            # ဒီအပိုင်းထဲမှာ ပုဒ်ချများစွာရှိပါက
-            # ပုဒ်ချအလိုက် ထပ်ခွဲမယ်။
-            parts = re.split(
-                r"(?<=။)",
-                chunk,
-            )
-
-            temp_chunk = ""
-
-            for part in parts:
-
-                part = part.strip()
-
-                if not part:
-                    continue
-
-                candidate = (
-                    temp_chunk + " " + part
-                ).strip()
-
-                if (
-                    temp_chunk
-                    and len(candidate) > MAX_CHUNK_CHARACTERS
-                ):
-
-                    final_chunks.append(
-                        temp_chunk
-                    )
-
-                    temp_chunk = part
-
-                else:
-
-                    temp_chunk = candidate
-
-            if temp_chunk:
-
-                if len(temp_chunk) > MAX_CHUNK_CHARACTERS:
-
-                    final_chunks.extend(
-                        split_long_text(
-                            temp_chunk,
-                            MAX_CHUNK_CHARACTERS,
-                        )
-                    )
-
-                else:
-
-                    final_chunks.append(
-                        temp_chunk
-                    )
-
-        else:
-
-            final_chunks.append(chunk)
-
-    # စာသားထဲရှိ စကားလုံးအစဉ်ကို စစ်မယ်။
-    verify_text_integrity(
-        text,
-        final_chunks,
-    )
-
-    return final_chunks
-
-
-# ==================================================
-# SUBTITLE SEGMENTATION
-# ==================================================
-
-def split_for_srt(
-    text,
-    words_per_subtitle=WORDS_PER_SUBTITLE,
-):
-    """
-    Split SRT text at whitespace boundaries.
-
-    Target: approximately 20 whitespace-separated tokens
-    per subtitle.
-    """
-
-    words = text.split()
-
-    result = []
-
-    for index in range(
-        0,
-        len(words),
-        words_per_subtitle,
-    ):
-
-        result.append(
-            " ".join(
-                words[
-                    index:index + words_per_subtitle
-                ]
-            )
-        )
-
-    verify_text_integrity(
-        text,
-        result,
-    )
-
-    return result
-
-
-def verify_text_integrity(
-    original,
-    subtitle_texts,
-):
-    """
-    Verify every whitespace-separated token is preserved
-    in the same order.
-    """
-
-    original_words = original.split()
-
-    output_words = []
-
-    for subtitle in subtitle_texts:
-
-        output_words.extend(
-            subtitle.split()
-        )
-
-    if original_words != output_words:
-
-        raise RuntimeError(
-            "စာသားစစ်ဆေးမှု မအောင်မြင်ပါ။ "
-            "စာသားအစဉ် သို့မဟုတ် စကားလုံး ပျောက်နေသည်။"
-        )
-
-    return True
-
-
-# ==================================================
-# TTS SPEED
-# ==================================================
-
-def speed_to_rate(speed):
-
-    speed = int(speed)
-
-    speed = max(
-        -50,
-        min(100, speed),
-    )
-
-    if speed >= 0:
-        return f"+{speed}%"
-
-    return f"{speed}%"
-
+    return chunks
 
-# ==================================================
-# AUDIO GENERATION
-# ==================================================
 
-async def synthesize_async(
-    text,
-    voice,
-    rate,
-    output_path,
-):
+# =========================================================
+# EDGE TTS GENERATION
+# =========================================================
 
+async def synthesize_one_chunk(text, voice, rate, output_path):
     communicate = edge_tts.Communicate(
         text=text,
         voice=voice,
         rate=rate,
     )
 
-    await communicate.save(
-        output_path
-    )
+    await communicate.save(output_path)
 
     if (
-        not os.path.isfile(output_path)
+        not os.path.exists(output_path)
         or os.path.getsize(output_path) < MIN_AUDIO_BYTES
     ):
+        raise RuntimeError("Edge TTS returned an empty audio chunk.")
 
-        raise RuntimeError(
-            "Edge TTS က အသံဖိုင်အလွတ် ပြန်ပေ���ထားသည်။"
-        )
 
+async def synthesize_chunks(text_chunks, voice, rate, temp_dir):
+    chunk_files = []
 
-def synthesize_chunk(
-    text,
-    voice,
-    rate,
-    output_path,
-):
+    for index, chunk in enumerate(text_chunks):
+        output_path = os.path.join(
+            temp_dir,
+            f"chunk_{index:05d}.mp3",
+        )
+
+        logger.info(
+            "Synthesizing chunk %s/%s (%s chars)",
+            index + 1,
+            len(text_chunks),
+            len(chunk),
+        )
 
-    asyncio.run(
-        synthesize_async(
-            text,
+        await synthesize_one_chunk(
+            chunk,
             voice,
             rate,
             output_path,
         )
-    )
-
-
-# ==================================================
-# AUDIO JOINING
-# ==================================================
 
-def load_and_trim_audio_part(part_path):
-    """
-    Load an audio part without trimming its beginning
-    or ending.
+        chunk_files.append(output_path)
 
-    No 150 ms trim is applied.
-    """
-
-    segment = AudioSegment.from_file(
-        part_path,
-        format="mp3",
-    )
+    return chunk_files
 
-    return segment
 
+# =========================================================
+# FFMPEG CONCAT
+# All-in-One ပုံစံအတိုင်း MP3 stream copy ဖြင့်ပေါင်းမည်။
+# Audio ကို trim မလုပ်ပါ။
+# =========================================================
 
-def combine_audio_parts(
-    audio_parts,
-    output_path,
-):
-    """
-    Join audio parts in their original order.
-    Preserve the beginning and ending of each part.
-    """
+def find_ffmpeg():
+    import shutil
 
-    if not audio_parts:
+    ffmpeg_path = shutil.which("ffmpeg")
 
+    if not ffmpeg_path:
         raise RuntimeError(
-            "ပေါင်းစပ်ရန် Audio အပိုင်း မရှိပါ။"
+            "FFmpeg မတွေ့ပါ။ Environment ထဲမှာ FFmpeg ထည့်ထားပါ။"
         )
 
-    combined_audio = AudioSegment.empty()
+    return ffmpeg_path
 
-    for part_path in audio_parts:
 
-        segment = load_and_trim_audio_part(
-            part_path
-        )
+def concatenate_mp3_files(chunk_files, output_path, temp_dir):
+    if not chunk_files:
+        raise RuntimeError("Audio chunks မရှိပါ။")
 
-        combined_audio += segment
+    ffmpeg = find_ffmpeg()
 
-    if len(combined_audio) <= 0:
+    concat_list = os.path.join(
+        temp_dir,
+        "concat_list.txt",
+    )
 
-        raise RuntimeError(
-            "ပေါင်းစပ်ထားသော Audio ဖိုင်တွင် အသံမရှိပါ။"
-        )
+    # FFmpeg concat demuxer အတွက် file list ရေးမည်။
+    with open(concat_list, "w", encoding="utf-8") as file:
+        for chunk_path in chunk_files:
+            absolute_path = os.path.abspath(chunk_path)
 
-    combined_audio.export(
+            # FFmpeg concat list အတွက် quote escaping
+            escaped_path = absolute_path.replace("'", "'\\''")
+
+            file.write(f"file '{escaped_path}'\n")
+
+    command = [
+        ffmpeg,
+        "-y",
+        "-f", "concat",
+        "-safe", "0",
+        "-i", concat_list,
+        "-c", "copy",
         output_path,
-        format="mp3",
-        bitrate="192k",
+    ]
+
+    logger.info("Joining audio chunks with FFmpeg stream copy.")
+
+    result = subprocess.run(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        check=False,
     )
 
+    if result.returncode != 0:
+        logger.error("FFmpeg concat failed: %s", result.stderr[-4000:])
+
+        raise RuntimeError(
+            "Audio ပေါင်းရာတွင် FFmpeg error ဖြစ်သွားပါတယ်။ "
+            "Logs ကိုစစ်ပါ။"
+        )
+
     if (
-        not os.path.isfile(output_path)
+        not os.path.exists(output_path)
         or os.path.getsize(output_path) < MIN_AUDIO_BYTES
     ):
+        raise RuntimeError("Final audio ဖိုင် မထွက်လာပါ။")
 
-        raise RuntimeError(
-            "ပေါင်းစပ်ထားသော Audio ဖိုင်ကို ထုတ်မရပါ။"
+
+# =========================================================
+# AUDIO DURATION
+# =========================================================
+
+def get_audio_duration(audio_path):
+    try:
+        import subprocess
+
+        result = subprocess.run(
+            [
+                find_ffmpeg().replace("ffmpeg", "ffprobe"),
+                "-v", "error",
+                "-show_entries", "format=duration",
+                "-of", "default=noprint_wrappers=1:nokey=1",
+                audio_path,
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=False,
         )
 
-    return len(combined_audio)
+        if result.returncode == 0:
+            return max(0.0, float(result.stdout.strip()))
+
+    except Exception:
+        logger.exception("ffprobe duration check failed.")
 
+    # ffprobe မရလျှင် pydub ဖြင့်စမ်းမည်။
+    try:
+        from pydub import AudioSegment
 
-# ==================================================
-# SRT TIMING
-# ==================================================
+        audio = AudioSegment.from_file(audio_path)
+        return len(audio) / 1000.0
 
-def format_srt_time(milliseconds):
+    except Exception:
+        logger.exception("Audio duration detection failed.")
+        return 0.0
 
-    milliseconds = max(
-        0,
-        int(milliseconds),
-    )
 
-    hours = milliseconds // 3600000
+# =========================================================
+# SRT GENERATION
+# =========================================================
 
-    milliseconds %= 3600000
+def srt_timestamp(seconds):
+    seconds = max(0.0, float(seconds))
 
-    minutes = milliseconds // 60000
+    total_ms = int(round(seconds * 1000))
 
-    milliseconds %= 60000
+    hours = total_ms // 3_600_000
+    total_ms %= 3_600_000
 
-    seconds = milliseconds // 1000
+    minutes = total_ms // 60_000
+    total_ms %= 60_000
 
-    milliseconds %= 1000
+    secs = total_ms // 1000
+    milliseconds = total_ms % 1000
 
     return (
         f"{hours:02d}:"
         f"{minutes:02d}:"
-        f"{seconds:02d},"
+        f"{secs:02d},"
         f"{milliseconds:03d}"
     )
 
 
-def make_srt_entries(
-    subtitle_texts,
-    total_duration_ms,
-):
-    """
-    Estimate timing proportionally by subtitle text length.
+def split_text_for_srt(text, words_per_subtitle=WORDS_PER_SUBTITLE):
+    text = clean_text(text)
 
-    This is not exact word-level audio alignment.
-    """
-
-    if not subtitle_texts:
+    if not text:
         return []
 
-    weights = [
-        max(
-            1,
-            len(text.replace(" ", "")),
-        )
-        for text in subtitle_texts
-    ]
-
-    total_weight = sum(weights)
+    # မြန်မာစာတွင် space မရှိသည့် စာသားများကို မခွဲမပစ်ဘဲ
+    # ရှိပြီးသား space များအလိုက် အုပ်စုဖွဲ့မည်။
+    words = text.split()
 
-    if total_weight <= 0:
+    if not words:
         return []
 
-    entries = []
-
-    elapsed = 0
-
-    for index, (text, weight) in enumerate(
-        zip(subtitle_texts, weights)
-    ):
-
-        start = elapsed
-
-        if index == len(subtitle_texts) - 1:
-
-            end = total_duration_ms
+    result = []
 
-        else:
+    for start in range(0, len(words), words_per_subtitle):
+        result.append(
+            " ".join(words[start:start + words_per_subtitle])
+        )
 
-            duration = round(
-                total_duration_ms
-                * weight
-                / total_weight
-            )
+    return result
 
-            elapsed += duration
 
-            end = elapsed
+def create_srt(text, duration, output_path):
+    subtitle_lines = split_text_for_srt(text)
 
-        entries.append(
-            {
-                "text": text,
-                "start": start,
-                "end": end,
-            }
-        )
+    if not subtitle_lines:
+        raise RuntimeError("SRT ထုတ်ရန် စာသားမရှိပါ။")
 
-    return entries
+    if duration <= 0:
+        # Duration မရသည့်အခါ fallback
+        duration = max(1.0, len(text) / 8.0)
 
+    # စာသားအရှည်အချိုးအစားအလိုက် အချိန်ခွဲမည်။
+    weights = [
+        max(1, len(line.strip()))
+        for line in subtitle_lines
+    ]
 
-def build_srt(entries):
+    total_weight = sum(weights)
 
-    blocks = []
+    current_time = 0.0
+    entries = []
 
-    for index, entry in enumerate(
-        entries,
+    for index, (line, weight) in enumerate(
+        zip(subtitle_lines, weights),
         start=1,
     ):
+        segment_duration = duration * weight / total_weight
 
-        start = format_srt_time(
-            entry["start"]
-        )
+        start_time = current_time
+        end_time = current_time + segment_duration
 
-        end = format_srt_time(
-            entry["end"]
-        )
+        # နောက်ဆုံး subtitle ကို audio duration နှင့်ညှိ
+        if index == len(subtitle_lines):
+            end_time = duration
 
-        blocks.append(
+        entries.append(
             f"{index}\n"
-            f"{start} --> {end}\n"
-            f"{entry['text']}"
+            f"{srt_timestamp(start_time)} --> "
+            f"{srt_timestamp(end_time)}\n"
+            f"{line}\n"
         )
 
-    return "\n\n".join(blocks) + "\n"
+        current_time = end_time
+
+    with open(output_path, "w", encoding="utf-8-sig") as file:
+        file.write("\n".join(entries))
 
 
-# ==================================================
-# MAIN GENERATION
-# ==================================================
+# =========================================================
+# MAIN GENERATION FUNCTION
+# =========================================================
 
 def generate_audio_and_srt(
-    script,
-    selected_voice,
+    text,
+    voice_label,
     speed,
     progress=gr.Progress(),
 ):
+    text = clean_text(text)
 
-    script = normalize_script(script)
-
-    if not script:
-
-        raise gr.Error(
-            "Script ထည့်ပေးပါ။"
-        )
-
-    voice_map = get_voice_map()
-
-    voice = voice_map.get(
-        selected_voice
-    )
+    if not text:
+        raise gr.Error("စာသားထည့်ပေးပါ။")
 
-    if not voice:
+    voice_id = VOICE_LABEL_TO_ID.get(voice_label)
 
+    if not voice_id:
         raise gr.Error(
-            "Voice ကို ပြန်ရွေးပေးပါ။"
+            "ရွေးထားတဲ့ Voice ကိုမတွေ့ပါ။ "
+            "Voice list ကို Refresh လုပ်ပြီး ထပ်ရွေးပါ။"
         )
 
-    voice_display = selected_voice
-
-    rate = speed_to_rate(speed)
-
-    tts_chunks = split_for_tts(
-        script
-    )
+    # Edge TTS rate format
+    speed = int(speed)
 
-    if not tts_chunks:
+    if speed > 0:
+        rate = f"+{speed}%"
+    else:
+        rate = f"{speed}%"
 
-        raise gr.Error(
-            "အသံထုတ်ရန် Script မရှိပါ။"
-        )
+    text_chunks = split_text_for_tts(text)
 
-    work_dir = tempfile.mkdtemp(
-        prefix="job_",
-        dir=OUTPUT_DIR,
-    )
+    if not text_chunks:
+        raise gr.Error("အသံထုတ်ရန် စာသားမရှိပါ။")
 
-    audio_path = os.path.join(
-        work_dir,
-        "output.mp3",
+    job_dir = tempfile.mkdtemp(
+        prefix="tts_job_",
+        dir=WORK_DIR,
     )
 
-    srt_path = os.path.join(
-        work_dir,
-        "output.srt",
-    )
+    output_audio = os.path.join(job_dir, "output.mp3")
+    output_srt = os.path.join(job_dir, "subtitles.srt")
 
     try:
-
         with JOB_SEMAPHORE:
+            progress(0.05, desc="စာသားပြင်ဆင်နေသည်...")
 
-            audio_parts = []
-
-            total_chunks = len(
-                tts_chunks
+            logger.info(
+                "Starting job: voice=%s, chunks=%s, chars=%s",
+                voice_id,
+                len(text_chunks),
+                len(text),
             )
 
-            for index, chunk in enumerate(
-                tts_chunks
-            ):
-
-                progress(
-                    0.75
-                    * index
-                    / total_chunks,
-                    desc=(
-                        f"Audio ထုတ်နေသည် "
-                        f"{index + 1}/{total_chunks}"
-                    ),
-                )
-
-                part_path = os.path.join(
-                    work_dir,
-                    f"part_{index:05d}.mp3",
-                )
+            progress(0.10, desc="Edge TTS အသံထုတ်နေသည်...")
 
-                synthesize_chunk(
-                    chunk,
-                    voice,
+            chunk_files = asyncio.run(
+                synthesize_chunks(
+                    text_chunks,
+                    voice_id,
                     rate,
-                    part_path,
-                )
-
-                audio_parts.append(
-                    part_path
+                    job_dir,
                 )
-
-            progress(
-                0.80,
-                desc="Audio ပေါင်းနေသည်...",
             )
 
-            duration_ms = combine_audio_parts(
-                audio_parts,
-                audio_path,
-            )
+            progress(0.80, desc="အသံအပိုင်းများကို ပေါင်းနေသည်...")
 
-            progress(
-                0.90,
-                desc="SRT ပြုလုပ်နေသည်...",
+            concatenate_mp3_files(
+                chunk_files,
+                output_audio,
+                job_dir,
             )
 
-            subtitle_texts = split_for_srt(
-                script
-            )
+            progress(0.92, desc="SRT ဖိုင်ထုတ်နေသည်...")
 
-            verify_text_integrity(
-                script,
-                subtitle_texts,
-            )
+            duration = get_audio_duration(output_audio)
 
-            entries = make_srt_entries(
-                subtitle_texts,
-                duration_ms,
+            create_srt(
+                text,
+                duration,
+                output_srt,
             )
 
-            with open(
-                srt_path,
-                "w",
-                encoding="utf-8-sig",
-                newline="\n",
-            ) as file:
+            progress(1.0, desc="ပြီးပါပြီ။")
 
-                file.write(
-                    build_srt(entries)
-                )
+        status = (
+            "ပြီးပါပြီ။\n"
+            f"Voice: {voice_label}\n"
+            f"စာလုံးရေ: {len(text)}\n"
+            f"Audio chunks: {len(text_chunks)}\n"
+            f"Audio ကြာချိန်: {duration:.2f} seconds"
+        )
 
-            progress(
-                1.0,
-                desc="ပြီးပါပြီ!",
-            )
+        return output_audio, output_srt, status
 
-            logger.info(
-                "Generation complete: voice=%s, "
-                "rate=%s, chars=%d, chunks=%d",
-                voice,
-                rate,
-                len(script),
-                total_chunks,
-            )
-
-            return (
-                audio_path,
-                srt_path,
-                (
-                    "အောင်မြင်ပါသည်!\n"
-                    f"Voice Character: {voice_display}\n"
-                    f"Speed: {rate}\n"
-                    f"Script: {len(script)} characters\n"
-                    f"Audio chunks: {total_chunks}\n"
-                    f"SRT lines: {len(subtitle_texts)}"
-                ),
-            )
+    except gr.Error:
+        raise
 
     except Exception as exc:
+        logger.exception("TTS generation failed.")
 
-        logger.exception(
-            "Audio/SRT generation failed"
+        raise gr.Error(
+            "အသံထုတ်ရာတွင် Error ဖြစ်သွားပါတယ်။ "
+            f"အကြောင်းရင်း: {str(exc)}"
         )
 
-        shutil.rmtree(
-            work_dir,
-            ignore_errors=True,
-        )
 
-        raise gr.Error(
-            f"Error: {type(exc).__name__}: "
-            f"{str(exc)[:400]}"
-        )
+# =========================================================
+# REFRESH VOICES
+# =========================================================
+
+def refresh_voices():
+    choices = load_voice_choices()
+
+    default_label = VOICE_ID_TO_LABEL.get(
+        DEFAULT_VOICE_ID,
+        choices[0] if choices else None,
+    )
 
+    return gr.Dropdown(
+        choices=choices,
+        value=default_label,
+        label="အသံရွေးချယ်ပါ",
+    )
 
-# ==================================================
-# USER INTERFACE
-# ==================================================
 
-initial_choices = get_voice_choices()
+# =========================================================
+# UI
+# =========================================================
 
-initial_voice = get_default_voice_label()
+initial_voice_choices = load_voice_choices()
 
+initial_voice = VOICE_ID_TO_LABEL.get(
+    DEFAULT_VOICE_ID,
+    initial_voice_choices[0] if initial_voice_choices else None,
+)
+
+theme = gr.themes.Soft()
 
 with gr.Blocks(
     title=APP_TITLE,
-    theme=gr.themes.Soft(),
+    theme=theme,
 ) as demo:
 
     gr.Markdown(
         """
-        # 🎙️ Myanmar Multilingual TTS Studio
+        # Myanmar Multilingual TTS Studio
 
-        မြန်မာအမည်များဖြင့် Voice ရွေးချယ်ပြီး
-        MP3 Audio နှင့် SRT Subtitle ကို တစ်ခါတည်း ထုတ်ယူပါ။
+        မြန်မာစာနှင့် Multilingual Neural Voice များကို
+        အသုံးပြုပြီး အသံနှင့် SRT ဖိုင် ထုတ်နိုင်ပါသည်။
         """
     )
 
     with gr.Row():
-
-        voice_input = gr.Dropdown(
-            choices=initial_choices,
+        voice_dropdown = gr.Dropdown(
+            choices=initial_voice_choices,
             value=initial_voice,
-            label="Voice Character",
+            label="အသံရွေးချယ်ပါ",
             interactive=True,
             scale=5,
         )
 
         refresh_button = gr.Button(
-            "🔄 Voice List ပြန်ယူမယ်",
-            scale=2,
+            "အသံစာရင်း Refresh",
+            scale=1,
         )
 
-    voice_status = gr.Markdown(
-        "နေတိုးကို Default Voice အဖြစ် ရွေးထားသည်။"
-    )
-
     script_input = gr.Textbox(
-        label="Script",
-        placeholder=(
-            "အသံထုတ်လိုသော စာသားကို ဒီနေရာမှာ ထည့်ပါ..."
-        ),
+        label="အသံထုတ်မည့် စာသား",
+        placeholder="ဒီနေရာမှာ စာသားထည့်ပါ...",
         lines=12,
         max_lines=30,
     )
 
-    speed_input = gr.Slider(
+    speed_slider = gr.Slider(
         minimum=-50,
         maximum=100,
         value=0,
         step=5,
-        label="အသံ Speed (%)",
-    )
-
-    gr.Markdown(
-        """
-        - Default Voice: နေတိုး
-        - SRT: Space ခြားထားသော စကားလုံး ၂၀ ဝန်းကျင်
-        - Speed: -50% မှ +100%
-        """
+        label="အသံအမြန်နှုန်း",
+        info="0% = ပုံမှန်၊ အနှုတ်တန်ဖိုး = နှေး၊ အပေါင်းတန်ဖိုး = မြန်",
     )
 
     generate_button = gr.Button(
-        "🎙️ Audio + SRT ထုတ်မယ်",
+        "အသံနှင့် SRT ထုတ်မည်",
         variant="primary",
-        size="lg",
     )
 
     status_output = gr.Textbox(
         label="အခြေအနေ",
         interactive=False,
-        lines=5,
+        lines=4,
     )
 
-    audio_output = gr.Audio(
-        label="🎧 MP3 Audio",
-        type="filepath",
-    )
+    with gr.Row():
+        audio_output = gr.Audio(
+            label="ထုတ်ထားသော အသံ",
+            type="filepath",
+        )
 
-    srt_output = gr.File(
-        label="📝 SRT Subtitle Download",
-    )
+        srt_output = gr.File(
+            label="SRT ဖိုင်",
+        )
 
     refresh_button.click(
         fn=refresh_voices,
         inputs=[],
-        outputs=[
-            voice_input,
-            voice_status,
-        ],
+        outputs=[voice_dropdown],
     )
 
     generate_button.click(
         fn=generate_audio_and_srt,
         inputs=[
             script_input,
-            voice_input,
-            speed_input,
+            voice_dropdown,
+            speed_slider,
         ],
         outputs=[
             audio_output,
             srt_output,
             status_output,
         ],
-        api_name="generate",
     )
 
+    gr.Markdown(
+        """
+        ---
+        **မှတ်ချက်:** အသံထုတ်ချိန်တွင် စာသားကို အပိုင်းငယ်များခွဲပြီး
+        နောက်ဆုံးတွင် FFmpeg ဖြင့် ပေါင်းစပ်ပေးပါသည်။
+        မူရင်းအသံအပိုင်းများကို ဖြတ်တောက်ခြင်း မပြုလုပ်ပါ။
+        """
+    )
 
-if __name__ == "__main__":
 
+# =========================================================
+# START SERVER
+# =========================================================
+
+if __name__ == "__main__":
     demo.queue(
-        max_size=10,
-        default_concurrency_limit=2,
-    ).launch(
+        max_size=5,
+        default_concurrency_limit=MAX_CONCURRENT_JOBS,
+    )
+
+    demo.launch(
         server_name="0.0.0.0",
-        server_port=int(
-            os.environ.get(
-                "PORT",
-                7860,
-            )
-        ),
+        server_port=int(os.environ.get("PORT", 7860)),
     )