termux-tts 0.1.1 → 1.3.0

package/termux_tts/cli.py

@@ -1,82 +1,127 @@
-"""
-Command-Line Interface for termux-tts:
-- termux-tts synth : Option A Deep Learning Neural Synthesis to File
-- termux-tts speak : Option B Android System Native Immediate Voice Output
-- termux-tts doctor: 12-Stage Vulkan GPU Hardware Diagnostics
-"""
-
-import argparse
-from .engine import load, doctor
-
-def main():
-    parser = argparse.ArgumentParser(
-        prog="termux-tts",
-        description="Termux Neural & Native Text-to-Speech Engine"
-    )
-    subparsers = parser.add_subparsers(dest="command", help="Sub-commands")
-
-    # 1. Synth (Option A: DSP Formant or ONNX Neural Vocoder to File)
-    synth_parser = subparsers.add_parser("synth", help="Synthesize text to audio WAV file (DSP / ONNX)")
-    synth_parser.add_argument("-t", "--text", required=True, help="Input text to synthesize")
-    synth_parser.add_argument("-o", "--output", default="output.wav", help="Output WAV filepath")
-    synth_parser.add_argument("-l", "--lang", default="ko", help="Language code (ko, en)")
-    synth_parser.add_argument("-e", "--engine", default="auto", choices=["auto", "dsp", "onnx"], help="Synthesis engine (dsp=zero-dependency, onnx=deep learning)")
-    synth_parser.add_argument("-m", "--model", default=None, help="Path to .onnx model file (required for onnx engine)")
-    synth_parser.add_argument("-p", "--preset", default="balanced", choices=["fast", "balanced", "expressive", "ultra"])
-    synth_parser.add_argument("-d", "--device", default="auto", choices=["auto", "gpu", "vulkan", "cpu"])
-    synth_parser.add_argument("-s", "--speed", type=float, default=1.0, help="Speech speed multiplier (0.5 to 2.0)")
-
-    # 2. Speak (Option B: Native Samsung/Google System Voice)
-    speak_parser = subparsers.add_parser("speak", help="Speak text directly through device speaker (Option B: Native)")
-    speak_parser.add_argument("-t", "--text", required=True, help="Input text to speak")
-    speak_parser.add_argument("-l", "--lang", default="ko", help="Language code (ko, en)")
-    speak_parser.add_argument("-s", "--stream", default="MUSIC", help="Audio stream (MUSIC, NOTIFICATION, ALARM)")
-
-    # 3. Doctor (Diagnostics)
-    subparsers.add_parser("doctor", help="Run 12-stage Vulkan GPU hardware diagnostics")
-
-    # ── AMEVA Component Protocol v1 ─────────────────────────────────────────
-    _protocol_available = False
-    try:
-        from ameva_component.cli_support import build_protocol_subcommands
-        build_protocol_subcommands(subparsers)
-        _protocol_available = True
-    except ImportError:
-        pass
-    # ────────────────────────────────────────────────────────────────────────
-
-    args = parser.parse_args()
-
-    if args.command == "synth":
-        with load(model=args.model, language=args.lang, preset=args.preset, device=args.device, engine=args.engine) as engine:
-            res = engine.synthesize(args.text, output=args.output, speed=args.speed)
-            print(f"[SUCCESS] Synthesized via {res.backend} ({res.model_name}) -> {args.output}")
-            print(f"  Duration: {res.duration_sec:.2f}s | Elapsed: {res.elapsed_ms:.1f}ms | RTF: {res.rtf:.4f}x")
-
-    elif args.command == "speak":
-        with load(language=args.lang) as engine:
-            res = engine.speak(args.text, stream=args.stream)
-            print(f"[SUCCESS] Spoken via {res.engine_name} on stream {args.stream} ({res.elapsed_ms:.1f}ms)")
-
-    elif args.command == "doctor":
-        diag = doctor()
-        print("=" * 60)
-        print("   TERMUX-TTS 12-STAGE VULKAN HARDWARE DIAGNOSTICS")
-        print("=" * 60)
-        for k, v in diag.items():
-            print(f"  - {k:30s}: {v}")
-        print("=" * 60)
-
-    elif args.command in ("component", "model", "instance") and _protocol_available:
-        from ameva_component.cli_support import dispatch_protocol
-        from termux_tts.control import TTSControl
-        dispatch_protocol(args, TTSControl())
-    elif args.command in ("component", "model", "instance"):
-        print("[ERROR] ameva-component-sdk not installed.", file=sys.stderr)
-        sys.exit(1)
-    else:
-        parser.print_help()
-
-if __name__ == "__main__":
-    main()
-
+"""
+Command-Line Interface for termux-tts:
+- termux-tts synth : Option A Deep Learning Neural Synthesis to File
+- termux-tts speak : Option B Android System Native Immediate Voice Output
+- termux-tts doctor: 12-Stage Vulkan GPU Hardware Diagnostics
+"""
+
+import os
+import sys
+import argparse
+from .engine import load, doctor
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="termux-tts",
+        description="Termux Neural & Native Text-to-Speech Engine"
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Sub-commands")
+
+    # 1. Synth (4-Tier Speech Synthesis)
+    synth_parser = subparsers.add_parser("synth", help="Synthesize text to audio WAV file (Synth, Neural, Expressive)")
+    synth_parser.add_argument("-t", "--text", required=True, help="Input text to synthesize")
+    synth_parser.add_argument("-o", "--output", default="output.wav", help="Output WAV filepath")
+    synth_parser.add_argument("-l", "--lang", default="ko", help="Language code (ko, en)")
+    synth_parser.add_argument(
+        "-e", "--engine", default="auto",
+        choices=["auto", "vulkan", "ncnn", "gpu", "synth", "dsp", "native", "neural", "onnx", "expressive"],
+        help="Synthesis engine tier (vulkan=GPU NCNN, synth=0MB DSP, native=Android voice, neural=VITS C++, expressive=emotional)"
+    )
+    synth_parser.add_argument("-m", "--model", default=None, help="Path to model file or directory")
+    synth_parser.add_argument("-p", "--preset", default="balanced", choices=["fast", "balanced", "expressive", "ultra"])
+    synth_parser.add_argument("-d", "--device", default="auto", choices=["auto", "gpu", "vulkan", "cpu"])
+    synth_parser.add_argument("-s", "--speed", type=float, default=1.0, help="Speech speed multiplier (0.5 to 2.0)")
+    synth_parser.add_argument("--threads", type=int, default=4, help="Compute worker threads (ARM NEON)")
+    synth_parser.add_argument("--volume", type=int, default=None, help="Set Android media volume (1 to 15)")
+    synth_parser.add_argument("--play", action="store_true", help="Play synthesized audio through physical speaker immediately")
+
+    # 2. Speak (Option B: Native Samsung/Google System Voice)
+    speak_parser = subparsers.add_parser("speak", help="Speak text directly through device speaker (Option B: Native)")
+    speak_parser.add_argument("-t", "--text", required=True, help="Input text to speak")
+    speak_parser.add_argument("-l", "--lang", default="ko", help="Language code (ko, en)")
+    speak_parser.add_argument("-s", "--stream", default="MUSIC", help="Audio stream (MUSIC, NOTIFICATION, ALARM)")
+    speak_parser.add_argument("--volume", type=int, default=None, help="Set Android media volume (1 to 15)")
+
+    # 3. Doctor (Diagnostics)
+    subparsers.add_parser("doctor", help="Run 12-stage Vulkan GPU hardware diagnostics")
+
+    # 4. Install (One-Click Automated Provisioner)
+    install_parser = subparsers.add_parser("install", help="1-Click download and provision precompiled Vulkan binary & VITS studio models")
+    install_parser.add_argument("--tier", default="high", choices=["high", "medium"], help="Model resolution tier (high=57MB Studio FP16, medium=25MB Fast)")
+    install_parser.add_argument("--force", action="store_true", help="Force overwrite existing binary and model assets")
+    install_parser.add_argument("--no-play", action="store_true", help="Skip playback verification during self-test")
+
+    # ── AMEVA Component Protocol v1 ─────────────────────────────────────────
+    _protocol_available = False
+    try:
+        from ameva_component.cli_support import build_protocol_subcommands
+        build_protocol_subcommands(subparsers)
+        _protocol_available = True
+    except ImportError as _proto_err:
+        _protocol_available = False
+    # ────────────────────────────────────────────────────────────────────────
+
+    args = parser.parse_args()
+
+    import subprocess
+    import shutil
+
+    if getattr(args, "volume", None) is not None:
+        if shutil.which("termux-volume"):
+            subprocess.run(["termux-volume", "music", str(args.volume)], check=False)
+
+    if args.command == "synth":
+        with load(
+            model=args.model,
+            language=args.lang,
+            preset=args.preset,
+            device=args.device,
+            threads=args.threads,
+            engine=args.engine,
+        ) as engine:
+            res = engine.synthesize(args.text, output=args.output, speed=args.speed)
+            backend_name = getattr(res, "backend", "UNKNOWN")
+            model_name = getattr(res, "model_name", "model")
+            dur = getattr(res, "duration_sec", 0.0)
+            elapsed = getattr(res, "elapsed_ms", 0.0)
+            rtf = getattr(res, "rtf", 0.0)
+            print(f"[SUCCESS] Synthesized via {backend_name} ({model_name}) -> {args.output}")
+            print(f"  Duration: {dur:.2f}s | Elapsed: {elapsed:.1f}ms | RTF: {rtf:.4f}x")
+
+            if args.play and args.output and os.path.exists(args.output):
+                if shutil.which("termux-media-player"):
+                    subprocess.run(["termux-media-player", "play", args.output], check=False)
+                elif shutil.which("play-audio"):
+                    subprocess.run(["play-audio", args.output], check=False)
+
+    elif args.command == "speak":
+        with load(language=args.lang) as engine:
+            res = engine.speak(args.text, stream=args.stream)
+            print(f"[SUCCESS] Spoken via {res.engine_name} on stream {args.stream} ({res.elapsed_ms:.1f}ms)")
+
+    elif args.command == "doctor":
+        diag = doctor()
+        print("=" * 60)
+        print("   TERMUX-TTS 12-STAGE VULKAN HARDWARE DIAGNOSTICS")
+        print("=" * 60)
+        for k, v in diag.items():
+            print(f"  - {k:30s}: {v}")
+        print("=" * 60)
+
+    elif args.command == "install":
+        from .installer import run_installation
+        run_installation(tier=args.tier, force=args.force, play=not args.no_play)
+
+    elif args.command in ("component", "model", "instance") and _protocol_available:
+        from ameva_component.cli_support import dispatch_protocol
+        from termux_tts.control import TTSControl
+        dispatch_protocol(args, TTSControl())
+    elif args.command in ("component", "model", "instance"):
+        print("[ERROR] ameva-component-sdk not installed.", file=sys.stderr)
+        sys.exit(1)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()
+

package/termux_tts/control/component.py

@@ -68,7 +68,9 @@ class TTSControl(ComponentControl):
         ts = now_timestamps()
         state_data = self._state_file.read()
         stale = self._state_file.is_stale(threshold_ms=30_000)
-        pid, pid_alive = self._check_pid()
+        pid_info = self._check_pid()
+        pid = pid_info.get("pid")
+        pid_alive = pid_info.get("alive")
         instances = self._inst_reg.list_all()
         hot = [i for i in instances if i.state == InstanceState.HOT]
 
@@ -78,11 +80,22 @@ class TTSControl(ComponentControl):
         try:
             from termux_tts.engine_onnx import ONNXNeuralEngine
             onnx_available = True
-        except ImportError:
-            pass
+        except ImportError as _imp_err:
+            import logging
+            logging.getLogger(__name__).debug("[tts] ONNXNeuralEngine not importable: %s", _imp_err)
 
         ready = dsp_available  # DSP는 Zero Dependency이므로 항상 최소 가용
-        degraded = stale or not pid_alive
+        degraded = stale or (pid_alive is not True)
+
+        proc_dict: dict[str, Any] = {
+            "running": pid_alive,
+            "pid": pid,
+            "verified": pid_info.get("verified", False),
+        }
+        if "inspection_error" in pid_info:
+            proc_dict["inspection_error"] = pid_info["inspection_error"]
+        if "reason" in pid_info:
+            proc_dict["reason"] = pid_info["reason"]
 
         return {
             "protocol":       "ameva-component-status/1",
@@ -92,7 +105,7 @@ class TTSControl(ComponentControl):
             "ready":          ready,
             "degraded":       degraded,
             **ts,
-            "process":        {"running": pid_alive, "pid": pid},
+            "process":        proc_dict,
             "capabilities":   list(self.CAPABILITIES),
             "active_models":  [i.model_id for i in hot],
             "backends": {
@@ -108,15 +121,104 @@ class TTSControl(ComponentControl):
             },
         }
 
-    def _check_pid(self) -> tuple[int | None, bool]:
+    def _check_pid(self) -> dict[str, Any]:
+        """BLOCKER 1: PID 파일 기반 프로세스 활성 여부 확인.
+        PermissionError/OSError 발생 시 alive=None, verified=False, inspection_error 반환."""
+        import logging
+        _log = logging.getLogger(__name__)
+
         if self.DEFAULT_PID_FILE.exists():
             try:
-                pid = int(self.DEFAULT_PID_FILE.read_text().strip())
+                raw = self.DEFAULT_PID_FILE.read_text().strip()
+                pid = int(raw)
+            except (ValueError, OSError) as parse_err:
+                _log.warning("[tts] PID file parse/read error: %s", parse_err)
+                return {
+                    "pid": None,
+                    "alive": None,
+                    "verified": False,
+                    "inspection_error": {
+                        "code": "PID_PARSE_ERROR",
+                        "message": str(parse_err),
+                    },
+                }
+
+            try:
                 os.kill(pid, 0)
-                return pid, True
-            except Exception:
-                pass
-        return None, False
+                return {"pid": pid, "alive": True, "verified": True}
+            except ProcessLookupError:
+                return {
+                    "pid": pid,
+                    "alive": False,
+                    "verified": True,
+                    "reason": "process_lookup_failed",
+                }
+            except PermissionError as perm_err:
+                _log.warning("[tts] PID alive check PermissionError: %s", perm_err)
+                return {
+                    "pid": pid,
+                    "alive": None,
+                    "verified": False,
+                    "inspection_error": {
+                        "code": "PROCESS_INSPECTION_PERMISSION_DENIED",
+                        "message": str(perm_err),
+                    },
+                }
+            except OSError as os_err:
+                _log.warning("[tts] PID alive check OSError: %s", os_err)
+                return {
+                    "pid": pid,
+                    "alive": None,
+                    "verified": False,
+                    "inspection_error": {
+                        "code": "PROCESS_INSPECTION_OS_ERROR",
+                        "message": str(os_err),
+                    },
+                }
+
+        state_data = self._state_file.read()
+        if state_data:
+            pid = state_data.get("process", {}).get("pid")
+            if pid:
+                try:
+                    os.kill(pid, 0)
+                    return {"pid": pid, "alive": True, "verified": True}
+                except ProcessLookupError:
+                    return {
+                        "pid": pid,
+                        "alive": False,
+                        "verified": True,
+                        "reason": "process_lookup_failed",
+                    }
+                except PermissionError as perm_err:
+                    _log.warning("[tts] State-file PID %d PermissionError: %s", pid, perm_err)
+                    return {
+                        "pid": pid,
+                        "alive": None,
+                        "verified": False,
+                        "inspection_error": {
+                            "code": "PROCESS_INSPECTION_PERMISSION_DENIED",
+                            "message": str(perm_err),
+                        },
+                    }
+                except OSError as os_err:
+                    _log.warning("[tts] State-file PID %d OSError: %s", pid, os_err)
+                    return {
+                        "pid": pid,
+                        "alive": None,
+                        "verified": False,
+                        "inspection_error": {
+                            "code": "PROCESS_INSPECTION_OS_ERROR",
+                            "message": str(os_err),
+                        },
+                    }
+
+        return {
+            "pid": None,
+            "alive": False,
+            "verified": True,
+            "reason": "pid_file_missing",
+        }
 
     def doctor_full(self) -> dict:
         """기존 TTSEngine doctor() 호출 — 12단계 Vulkan Doctor 포함."""
@@ -240,3 +342,56 @@ class TTSControl(ComponentControl):
             "ready": _ready, "degraded": not _ready, **ts,
             "active_models": [i.model_id for i in hot], "last_error": last_error,
         })
+
+    async def synthesize(self, request: dict[str, Any]) -> dict[str, Any]:
+        """AMEVA Component Protocol v1 synthesize method."""
+        text = request.get("text", "").strip()
+        if not text:
+            return {
+                "ok": False,
+                "error": {
+                    "code": "TEXT_EMPTY",
+                    "message": "Input text cannot be empty",
+                }
+            }
+
+        voice_id = request.get("voice_id")
+        model_id = request.get("model_id")
+        output_path = request.get("output_path")
+        engine_type = request.get("engine", "auto")
+        device = request.get("device", "auto")
+
+        try:
+            from termux_tts.engine import TTSEngine
+            model_file = str(self._models_dir / model_id) if model_id else None
+            engine = TTSEngine(
+                model_path=model_file,
+                engine_type=engine_type,
+                device=device,
+            )
+            res = engine.synthesize(text, output=output_path)
+
+            out_file = output_path
+            if not out_file and hasattr(res, "save"):
+                import tempfile
+                with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+                    out_file = f.name
+                res.save(out_file)
+
+            return {
+                "ok": True,
+                "audio_path": out_file or getattr(res, "output_path", None),
+                "duration_sec": getattr(res, "duration_sec", 0.0),
+                "sample_rate": getattr(res, "sample_rate", 22050),
+                "model_id": getattr(res, "model_name", model_id or "default"),
+                "backend": getattr(res, "backend", "unknown"),
+                "fallback_used": False,
+            }
+        except Exception as e:
+            return {
+                "ok": False,
+                "error": {
+                    "code": "SYNTHESIZE_FAILED",
+                    "message": str(e),
+                }
+            }