perf: sentence-splitting para síntese por sentença dentro de uma GPU call

Divide o texto em sentenças antes de sintetizar, processando cada uma
individualmente em loop dentro do mesmo @spaces.GPU. Benefícios:

- RTF melhor: sequências curtas geram tokens mais rápido (atenção quadrática)
- Cache reutilizado: use_memory_cache="on" carrega a voz 1x para todas
- Sem ruído de cauda: cada sentença para limpa em seu ponto final
- max_new_tokens ajustado por sentença (não pelo texto inteiro)

_split_sentences(): quebra em pontuação forte, funde sentençs curtas
(<60 chars) e subdivide longas (>220 chars) na vírgula mais próxima.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app.py

@@ -4,31 +4,83 @@ from typing import Optional
 
 
 def _clean_text(text: str) -> str:
-    """Remove emojis, formatação markdown e normaliza espaços.
-
-    Emojis e caracteres fora do Latin Extended causam tokens inesperados no
-    Fish Speech, aumentando o tempo de geração sem contribuir para o áudio.
-    """
+    """Remove emojis, formatação markdown e normaliza espaços."""
     # Remove markdown: **bold**, *italic*, __underline__, _italic_, `code`
     text = re.sub(r'\*{1,3}([^*\n]*)\*{1,3}', r'\1', text)
     text = re.sub(r'_{1,2}([^_\n]*)_{1,2}', r'\1', text)
     text = re.sub(r'`[^`]*`', '', text)
     # Remove emojis e símbolos fora do BMP / Latin Extended
     text = re.sub(
-        u"[\U0001F600-\U0001F64F"   # emoticons
-        u"\U0001F300-\U0001F5FF"    # símbolos & pictogramas
-        u"\U0001F680-\U0001F6FF"    # transporte
-        u"\U0001F900-\U0001FA9F"    # símbolos extras
-        u"\U00002702-\U000027B0"    # dingbats
-        u"\U0001F1E0-\U0001F1FF"    # bandeiras
-        u"\U0000FE0F"               # variation selector
+        u"[\U0001F600-\U0001F64F"
+        u"\U0001F300-\U0001F5FF"
+        u"\U0001F680-\U0001F6FF"
+        u"\U0001F900-\U0001FA9F"
+        u"\U00002702-\U000027B0"
+        u"\U0001F1E0-\U0001F1FF"
+        u"\U0000FE0F"
         u"]+", '', text
     )
-    # Colapsa espaços/linhas excessivos
     text = re.sub(r'[ \t]+', ' ', text)
     text = re.sub(r'\n{3,}', '\n\n', text)
     return text.strip()
 
+
+def _split_sentences(text: str, min_len: int = 60, max_len: int = 220) -> list:
+    """Divide texto em sentenças para síntese individual.
+
+    Estratégia:
+    - Quebra em pontuação de fim de frase (. ! ? : ) seguida de espaço/newline
+    - Itens de lista numerados/marcados viram sentenças separadas
+    - Sentenças muito curtas são fundidas com a próxima (até min_len chars)
+    - Sentenças muito longas são subdivididas na vírgula mais próxima do meio
+
+    Cada sentença é sintetizada individualmente dentro de uma única chamada GPU,
+    aproveitando o cache de voz e a melhor RTF de sequências curtas.
+    """
+    # Normaliza quebras de linha
+    text = re.sub(r'\r\n', '\n', text)
+
+    # Divide em partes brutas por pontuação forte ou quebra de parágrafo
+    parts = re.split(r'(?<=[.!?:])\s+|\n{2,}', text)
+
+    # Também quebra itens de lista (1. / 2. / - / •)
+    expanded = []
+    for part in parts:
+        items = re.split(r'(?m)(?=^\s*(?:\d+[.)]\s+|-\s+))', part)
+        expanded.extend(i.strip() for i in items if i.strip())
+
+    # Funde sentenças muito curtas com a seguinte
+    merged = []
+    buf = ""
+    for s in expanded:
+        buf = (buf + " " + s).strip() if buf else s
+        if len(buf) >= min_len:
+            merged.append(buf)
+            buf = ""
+    if buf:
+        if merged:
+            merged[-1] = merged[-1] + " " + buf
+        else:
+            merged.append(buf)
+
+    # Subdivide sentenças muito longas na vírgula mais próxima do meio
+    result = []
+    for s in merged:
+        if len(s) <= max_len:
+            result.append(s)
+            continue
+        # Tenta quebrar na vírgula mais próxima do meio
+        mid = len(s) // 2
+        commas = [m.start() for m in re.finditer(r',\s', s)]
+        if commas:
+            cut = min(commas, key=lambda i: abs(i - mid))
+            result.append(s[:cut + 1].strip())
+            result.append(s[cut + 1:].strip())
+        else:
+            result.append(s)
+
+    return [s for s in result if s]
+
 # Instala fish-speech@v1.5.1 sem suas deps (evita conflito com gradio 6.x).
 # Os deps necessários já estão em requirements.txt.
 print("Instalando fish-speech@v1.5.1 (--no-deps)...")
@@ -334,33 +386,35 @@ def synthesize(text: str, speaker_wav: str, speaker_text: str, language: str = "
             ref_bytes = f.read()
 
         text = _clean_text(text)
-        # max_new_tokens proporcional ao texto: ~8 tokens/char, mínimo 512, máximo 4096
-        max_tokens = min(4096, max(512, len(text) * 8))
-
-        req = ServeTTSRequest(
-            text=text,
-            references=[ServeReferenceAudio(audio=ref_bytes, text=speaker_text or "")],
-            max_new_tokens=max_tokens,
-            top_p=0.7,
-            repetition_penalty=1.2,
-            temperature=0.7,
-            format="wav",
-            normalize=True,           # Fish Speech normaliza números/abreviações
-            use_memory_cache="on",    # cacheia embedding de voz entre chamadas
-        )
+        sentences = _split_sentences(text)
+        print(f"=== Sintetizando {len(sentences)} sentença(s) ===", flush=True)
+        for i, s in enumerate(sentences, 1):
+            print(f"  [{i}] ({len(s)} chars): {s[:80]}...", flush=True)
 
-        # Em modo não-streaming (padrão), fish-speech emite code="final" com o
-        # áudio completo concatenado. Em streaming, emite code="segment" por chunk.
-        # Coletamos de ambos para cobrir os dois casos.
         audio_chunks = []
         out_sr = 44100
-        for result in _engine.inference(req):
-            if result.code == "error":
-                raise RuntimeError(f"Fish Speech error: {result.error}")
-            if result.code in ("segment", "final") and result.audio is not None:
-                sr, chunk = result.audio
-                out_sr = sr
-                audio_chunks.append(chunk.astype(np.float32))
+
+        for sent in sentences:
+            # max_new_tokens proporcional à sentença: ~8 tok/char, min 128, max 1024
+            max_tokens = min(1024, max(128, len(sent) * 8))
+            req = ServeTTSRequest(
+                text=sent,
+                references=[ServeReferenceAudio(audio=ref_bytes, text=speaker_text or "")],
+                max_new_tokens=max_tokens,
+                top_p=0.7,
+                repetition_penalty=1.2,
+                temperature=0.7,
+                format="wav",
+                normalize=True,
+                use_memory_cache="on",  # cache de voz reutilizado em todas as sentenças
+            )
+            for result in _engine.inference(req):
+                if result.code == "error":
+                    raise RuntimeError(f"Fish Speech error: {result.error}")
+                if result.code in ("segment", "final") and result.audio is not None:
+                    sr, chunk = result.audio
+                    out_sr = sr
+                    audio_chunks.append(chunk.astype(np.float32))
 
         if not audio_chunks:
             raise RuntimeError("Nenhum áudio gerado pela inferência.")