Trim sentence edges; sentence_pause_ms (default 350 ms)

README.md

@@ -69,6 +69,7 @@ python -m swar.inference "नमस्ते, यहाँलाई स्वा
 | `voice` | a name from `voices/` (default `bijaya`), a `.pt` of style vectors, or an audio clip (wav / flac / mp3 / ogg) |
 | `speed` | 0.5-2.0, scales the predicted durations (1.0 = as predicted) |
 | `pause_floor_ms` | every comma / full stop / question mark *inside* a sentence lasts at least this long (0 = as predicted) |
+| `sentence_pause_ms` | silence between two sentences (default 350); the start and end of each sentence are trimmed, so the first sound comes within about 0.1 s |
 | `return_info` | also return timing and the exact letters the model read |
 
 ## What is inside

swar/inference.py

@@ -4,7 +4,7 @@
     tts = Swar.from_pretrained("elitexp/Swar")          # or a local folder
     wav, sr = tts.synthesize("नमस्ते, यहाँलाई स्वागत छ।")  # default voice: bijaya
     wav, sr = tts.synthesize("Your balance is Rs. 250.", voice="path/to/reference.wav",
-                             speed=1.0, pause_floor_ms=300)
+                             speed=1.0, pause_floor_ms=300, sentence_pause_ms=350)
 
     python -m swar.inference "नमस्ते, यहाँलाई स्वागत छ।" -o hello.wav
 
@@ -13,6 +13,12 @@ prosodic (manner of speaking, read by the duration / pitch / energy predictor).
 voices/*.pt hold them ready-made; any clean 3-10 s clip of one speaker gives a new
 voice through style_from_audio(). pause_floor_ms makes every comma / full stop /
 question mark inside a sentence last at least that long.
+
+Sentences are generated one at a time. Training clips began and ended with room
+silence, so the model gives the start and end tokens 0.3-0.5 s each; joined
+sentence by sentence that piled up to ~1 s at every full stop and delayed the first
+sound. So the edges are cut to EDGE_UNITS, and the gap between two sentences is
+exactly sentence_pause_ms, carried by the first sentence's final punctuation.
 """
 from __future__ import annotations
 
@@ -29,7 +35,9 @@ from .model import build, conf
 from .text import STOI, normalize, to_ids
 
 PAUSE_CHARS = ",.?!;:…—"
-GAP_S = 0.15                                                       # silence between sentences
+UNIT_S = 0.025                                                     # one duration unit
+EDGE_UNITS = 2                                                     # start / end token cap (50 ms)
+TAIL_UNITS = 4                                                     # after the last sentence (100 ms)
 MAX_CHARS = 220
 
 
@@ -65,6 +73,7 @@ class Swar:
         self.m = m.to(self.device).eval()
         self.mel = Mel().to(self.device)
         self._pause_ids = torch.tensor([STOI[c] for c in PAUSE_CHARS], device=self.device)
+        self._pause_set = {STOI[c] for c in PAUSE_CHARS}
         self._voices: dict[str, tuple[torch.Tensor, torch.Tensor]] = {}
 
     @classmethod
@@ -106,7 +115,10 @@ class Swar:
 
     # ---- synthesis
     @torch.no_grad()
-    def _tts(self, ids: list[int], s_ac, s_pr, speed: float, pause_floor: int) -> torch.Tensor:
+    def _tts(self, ids: list[int], s_ac, s_pr, speed: float, pause_floor: int,
+             end_pause: int | None = None, tail: int = EDGE_UNITS) -> torch.Tensor:
+        """end_pause: units for the sentence-final punctuation (None = as predicted); the
+        last sentence gets a short one, so the clip does not end in half a second of nothing."""
         m, dev = self.m, self.device
         x_ids = torch.tensor([ids], device=dev)
         n = torch.tensor([len(ids)], device=dev)
@@ -121,30 +133,39 @@ class Swar:
             pos = torch.arange(L, device=dev)
             p = torch.isin(x_ids[0], self._pause_ids) & (pos > 0) & (pos < L - 2)   # inside the sentence
             dur[0, p] = dur[0, p].clamp(min=pause_floor)
+        dur[0, 0] = dur[0, 0].clamp(max=EDGE_UNITS)                 # room silence before the sentence
+        dur[0, -1] = dur[0, -1].clamp(max=tail)                      # ... and after it
+        if end_pause is not None and ids[-2] in self._pause_set:
+            dur[0, -2] = max(1, end_pause)
         aln = _alignment(dur, int(dur.sum()))
         F0, N = m["predictor"].F0Ntrain(d.transpose(-1, -2) @ aln, s_pr)
         asr = m["text_encoder"](x_ids, n.cpu(), mask) @ aln
         return m["decoder"](asr, F0, N, s_ac).squeeze().clamp(-1, 1)
 
     def synthesize(self, text: str, voice: str | Path | None = None, speed: float = 1.0,
-                   pause_floor_ms: int = 0, return_info: bool = False):
+                   pause_floor_ms: int = 0, sentence_pause_ms: int = 350, return_info: bool = False):
         """-> (float32 waveform, 16000), plus a timing dict if return_info."""
         t0 = time.time()
         s_ac, s_pr = self.voice(voice)
         floor = int(round(pause_floor_ms / 25))
         speed = float(min(2.0, max(0.5, speed)))
-        pieces, sentences, first = [], [], None
+        gap = int(round(max(0, sentence_pause_ms) / 1000 / UNIT_S)) - 2 * EDGE_UNITS   # edges are silent too
         # split the RAW text first, so each sentence's numbers are read in its own
         # language ("Rs. 250" stays together: no split before a digit)
         raws = re.split(r"(?<=[।?!])\s+|(?<=\.)\s+(?![0-9०-९])", text)
-        for sent in (s for raw in raws for s in split_sentences(normalize(raw))):
-            sentences.append(sent)
-            y = self._tts(to_ids(sent), s_ac, s_pr, speed, floor).float().cpu().numpy()
-            first = first if first is not None else time.time() - t0
-            pieces += [y, np.zeros(int(GAP_S * SR), np.float32)]
-        if not pieces:
+        sentences = [s for raw in raws for s in split_sentences(normalize(raw))]
+        if not sentences:
             raise ValueError("nothing speakable left after normalising the text")
-        wav = np.concatenate(pieces[:-1])
+        pieces, first = [], None
+        for k, sent in enumerate(sentences):
+            last = k == len(sentences) - 1
+            y = self._tts(to_ids(sent), s_ac, s_pr, speed, floor, end_pause=TAIL_UNITS if last else gap,
+                          tail=TAIL_UNITS if last else EDGE_UNITS).float().cpu().numpy()
+            first = first if first is not None else time.time() - t0
+            pieces.append(y)
+            if not last and sent[-1] not in PAUSE_CHARS:            # cut mid run-on: pause as silence
+                pieces.append(np.zeros(int(max(0, gap) * UNIT_S * SR), np.float32))
+        wav = np.concatenate(pieces)
         if not return_info:
             return wav, SR
         return wav, SR, {"first_audio_sec": round(first, 3), "total_sec": round(time.time() - t0, 3),
@@ -159,12 +180,14 @@ def main() -> int:
     ap.add_argument("--voice", default=None, help="voice name, .pt, or a reference audio clip")
     ap.add_argument("--speed", type=float, default=1.0)
     ap.add_argument("--pause-floor-ms", type=int, default=0)
+    ap.add_argument("--sentence-pause-ms", type=int, default=350)
     ap.add_argument("--device", default=None)
     a = ap.parse_args()
     import soundfile as sf
     tts = Swar.from_pretrained(a.model, device=a.device)
     wav, sr, info = tts.synthesize(a.text, voice=a.voice, speed=a.speed,
-                                   pause_floor_ms=a.pause_floor_ms, return_info=True)
+                                   pause_floor_ms=a.pause_floor_ms, sentence_pause_ms=a.sentence_pause_ms,
+                                   return_info=True)
     sf.write(a.out, wav, sr)
     print(f"{a.out}: {info['duration_sec']} s audio in {info['total_sec']} s -- read as: "
           f"{' | '.join(info['sentences'])}")