Adding support for Stable Signer mainly involves adding support for plugin aliases.

easy_dwpose/__init__.py

@@ -1,3 +1,7 @@
-from easy_dwpose.dwpose import DWposeDetector
-
 __all__ = ["DWposeDetector"]
+
+def __getattr__(name):
+    if name == "DWposeDetector":
+        from .dwpose import DWposeDetector  # Local import to avoid heavy deps until needed
+        return DWposeDetector
+    raise AttributeError(name)

gloss2pose.py

@@ -16,17 +16,133 @@ import cv2
 from tqdm import tqdm
 import re
 from datetime import datetime
+import shutil
+import subprocess
+from typing import Optional
+
+_DWposeDetector = None
+_DWPOSE_IMPORT_ERROR = None
+
+
+def _ensure_dwpose_imported():
+    """Lazy import DWposeDetector to avoid hard dependency unless needed."""
+    global _DWposeDetector, _DWPOSE_IMPORT_ERROR  # noqa: PLW0603
+    if _DWposeDetector is not None or _DWPOSE_IMPORT_ERROR is not None:
+        return
+    try:
+        from easy_dwpose import DWposeDetector  # type: ignore
+        _DWposeDetector = DWposeDetector
+    except Exception as exc:  # pylint: disable=broad-except
+        _DWPOSE_IMPORT_ERROR = exc
 
-from easy_dwpose import DWposeDetector
 from easy_dwpose.draw.controlnext import draw_pose as draw_pose_controlnext, process_pose_data
 from easy_dwpose.draw.openpose import draw_pose as draw_pose_openpose
 from utils.npz_interpolation import interpolate_pose_npz, ease_in_out_cubic
 import copy
 
-# Fixed configuration
-JSON_FILE = "pose_dict/WLASL_train.json"  # JSON mapping file
-NPZ_DIR = "pose_dict/WLASL_train"  # Directory containing NPZ files
-OUTPUT_DIR = "generated_pose_video"  # Output video directory
+# Fixed configuration (resolve relative to this file so plugins/symlinks work)
+BASE_DIR = Path(__file__).resolve().parent
+POSE_DICT_ROOT = BASE_DIR / "pose_dict"
+JSON_FILE = os.environ.get(
+    "STABLE_SIGNER_GLOSS_JSON",
+    str(POSE_DICT_ROOT / "WLASL_train.json"),
+)  # JSON mapping file
+NPZ_DIR = os.environ.get(
+    "STABLE_SIGNER_NPZ_DIR",
+    str(POSE_DICT_ROOT / "WLASL_train"),
+)  # Directory containing NPZ files
+OUTPUT_DIR = os.environ.get(
+    "STABLE_SIGNER_OUTPUT_DIR",
+    str(BASE_DIR / "generated_pose_video"),
+)  # Output video directory
+
+_FFMPEG_BINARY = None
+
+
+def _known_ffmpeg_search_roots() -> list[Path]:
+    roots = []
+    env_hint = os.environ.get("STABLE_SIGNER_FFMPEG")
+    if env_hint:
+        roots.append(Path(env_hint).parent if Path(env_hint).is_file() else Path(env_hint))
+
+    env_dir_hint = os.environ.get("STABLE_SIGNER_FFMPEG_DIR")
+    if env_dir_hint:
+        roots.append(Path(env_dir_hint))
+
+    roots.extend(
+        [
+            BASE_DIR / "tools",
+            Path.home() / "miniforge3",
+            Path.home() / "miniconda3",
+            Path.home() / "anaconda3",
+            Path("/research/cbim/vast/sf895/miniforge3"),
+        ]
+    )
+
+    # Remove duplicates while preserving order
+    seen = set()
+    unique_roots = []
+    for root in roots:
+        if not root:
+            continue
+        try:
+            key = str(root.resolve())
+        except Exception:
+            key = str(root)
+        if key in seen:
+            continue
+        seen.add(key)
+        unique_roots.append(root)
+    return unique_roots
+
+
+def _probe_ffmpeg_in_known_locations() -> Optional[str]:
+    patterns = [
+        "lib/python*/site-packages/imageio_ffmpeg/binaries/ffmpeg*",
+        "envs/*/lib/python*/site-packages/imageio_ffmpeg/binaries/ffmpeg*",
+        "site-packages/imageio_ffmpeg/binaries/ffmpeg*",
+        "imageio_ffmpeg/binaries/ffmpeg*",
+        "ffmpeg*",
+    ]
+    for root in _known_ffmpeg_search_roots():
+        if not root or not root.exists():
+            continue
+        for pattern in patterns:
+            for candidate in root.glob(pattern):
+                if candidate.is_file() and os.access(candidate, os.X_OK):
+                    return str(candidate)
+    return None
+
+
+def _get_ffmpeg_binary() -> str:
+    """Locate an FFmpeg executable that actually works inside this environment."""
+    global _FFMPEG_BINARY  # noqa: PLW0603
+    if _FFMPEG_BINARY:
+        return _FFMPEG_BINARY
+
+    try:
+        from imageio_ffmpeg import get_ffmpeg_exe  # type: ignore
+
+        ffmpeg_path = get_ffmpeg_exe()
+        if ffmpeg_path and Path(ffmpeg_path).exists():
+            _FFMPEG_BINARY = ffmpeg_path
+            return ffmpeg_path
+    except Exception:
+        pass
+
+    probed = _probe_ffmpeg_in_known_locations()
+    if probed:
+        _FFMPEG_BINARY = probed
+        return probed
+
+    fallback = shutil.which("ffmpeg")
+    if fallback:
+        _FFMPEG_BINARY = fallback
+        return fallback
+
+    # Last resort: just return string "ffmpeg" and let subprocess raise a clearer error.
+    _FFMPEG_BINARY = "ffmpeg"
+    return _FFMPEG_BINARY
 
 
 class SignLanguageQA:
@@ -711,9 +827,16 @@ class SignLanguageQA:
         """Get the top of head position from reference image"""
         try:
             # Lazy load detector
+            _ensure_dwpose_imported()
+            if _DWposeDetector is None:
+                if _DWPOSE_IMPORT_ERROR:
+                    print(f"⚠️  DWposeDetector unavailable: {_DWPOSE_IMPORT_ERROR}")
+                else:
+                    print("⚠️  DWposeDetector module not available")
+                return None
             if self.detector is None:
                 device = "cuda:0" if torch.cuda.is_available() else "cpu"
-                self.detector = DWposeDetector(device=device)
+                self.detector = _DWposeDetector(device=device)
             
             # Load and detect pose in reference image
             ref_image = Image.open(ref_image_path).convert("RGB")
@@ -1036,9 +1159,12 @@ class SignLanguageQA:
             import subprocess
             import threading
 
+            ffmpeg_path = _get_ffmpeg_binary()
+            print(f"   ▶ Using FFmpeg binary: {ffmpeg_path}")
+
             # Create FFmpeg command for pipe input
             ffmpeg_cmd = [
-                'ffmpeg',
+                ffmpeg_path,
                 '-y',  # Overwrite output file
                 '-f', 'rawvideo',
                 '-vcodec', 'rawvideo',
@@ -1103,8 +1229,9 @@ class SignLanguageQA:
         # Fallback to OpenCV if FFmpeg pipe fails
         if not use_ffmpeg_pipe:
             print("⚠️  Falling back to OpenCV writer...")
+            tmp_output_path = output_path.with_name(f"{output_path.stem}_mp4v_tmp{output_path.suffix}")
             fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-            video_writer = cv2.VideoWriter(str(output_path), fourcc, fps, (width, height))
+            video_writer = cv2.VideoWriter(str(tmp_output_path), fourcc, fps, (width, height))
             
             if not video_writer.isOpened():
                 print("❌ Unable to create video file")
@@ -1115,7 +1242,37 @@ class SignLanguageQA:
                 video_writer.write(pose_frame_bgr)
             
             video_writer.release()
-            print(f"✅ Video generated successfully!")
+            print("✅ Video generated successfully (raw MP4V). Re-encoding to H.264 for browser compatibility...")
+
+            try:
+                ffmpeg_bin = _get_ffmpeg_binary()
+                print(f"   ▶ Using FFmpeg binary: {ffmpeg_bin}")
+                reencode_cmd = [
+                    ffmpeg_bin,
+                    '-y',
+                    '-i', str(tmp_output_path),
+                    '-c:v', 'libx264',
+                    '-pix_fmt', 'yuv420p',
+                    '-movflags', '+faststart',
+                    str(output_path)
+                ]
+                result = subprocess.run(
+                    reencode_cmd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    check=True
+                )
+                tmp_output_path.unlink(missing_ok=True)
+                print("✅ Re-encoded video with libx264 successfully!")
+                if result.stderr:
+                    stderr_tail = result.stderr.decode('utf-8', errors='ignore')[-300:]
+                    if stderr_tail.strip():
+                        print(stderr_tail)
+            except Exception as re_err:
+                print(f"⚠️  H.264 re-encode failed: {re_err}")
+                print("    Keeping MP4V file; some browsers may not play it.")
+                if tmp_output_path.exists():
+                    shutil.move(str(tmp_output_path), str(output_path))
         
         print(f"   📁 File: {output_path}")
         print(f"   📊 {len(final_frames)} frames, {fps}fps, {width}x{height}")

index.js

@@ -0,0 +1,620 @@
+import { ControlWavePlugin } from '../plugin-loader.js';
+
+const STYLE_ID = 'stable-signer-plugin-style';
+const toInt = (value, fallback) => {
+    const parsed = parseInt(value, 10);
+    return Number.isNaN(parsed) ? fallback : parsed;
+};
+const toFloat = (value, fallback) => {
+    const parsed = parseFloat(value);
+    return Number.isNaN(parsed) ? fallback : parsed;
+};
+
+function ensureStyles() {
+    if (document.getElementById(STYLE_ID)) {
+        return;
+    }
+
+    const style = document.createElement('style');
+    style.id = STYLE_ID;
+    style.textContent = `
+        .stable-signer-root {
+            display: flex;
+            gap: 20px;
+            width: 100%;
+            height: 100%;
+            padding: 20px;
+            box-sizing: border-box;
+        }
+        .stable-signer-left,
+        .stable-signer-right {
+            background: #fff;
+            border-radius: 12px;
+            box-shadow: 0 4px 16px rgba(15, 23, 42, 0.08);
+            padding: 20px;
+            display: flex;
+            flex-direction: column;
+        }
+        .stable-signer-left {
+            flex: 1.2;
+        }
+        .stable-signer-right {
+            flex: 1;
+        }
+        .stable-video-frame {
+            position: relative;
+            width: 100%;
+            padding-top: 56.25%;
+            background: #0f172a;
+            border-radius: 10px;
+            overflow: hidden;
+        }
+        .stable-video-frame video {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            object-fit: contain;
+            background: #0f172a;
+        }
+        .stable-video-placeholder {
+            position: absolute;
+            inset: 0;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            color: #94a3b8;
+            font-size: 15px;
+            text-align: center;
+            padding: 20px;
+        }
+        .stable-video-controls {
+            margin-top: 15px;
+            display: flex;
+            gap: 10px;
+            align-items: center;
+        }
+        .stable-video-controls select,
+        .stable-video-controls button {
+            flex: 1;
+        }
+        .stable-meta {
+            font-family: "JetBrains Mono", "Fira Code", monospace;
+            background: #0f172a;
+            color: #e2e8f0;
+            padding: 12px;
+            border-radius: 8px;
+            margin-top: 15px;
+            min-height: 60px;
+            font-size: 13px;
+        }
+        .stable-control-header {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            gap: 12px;
+            margin-bottom: 15px;
+        }
+        .stable-control-header button {
+            flex: none;
+        }
+        .stable-status-chip {
+            font-size: 13px;
+            padding: 6px 12px;
+            border-radius: 999px;
+            background: #e2e8f0;
+            color: #0f172a;
+        }
+        .stable-form-row {
+            display: flex;
+            gap: 12px;
+            margin-bottom: 15px;
+        }
+        .stable-form-row .form-group {
+            flex: 1;
+        }
+        .form-group label {
+            font-size: 13px;
+            font-weight: 600;
+            display: block;
+            margin-bottom: 6px;
+            color: #0f172a;
+        }
+        .form-group textarea,
+        .form-group input,
+        .form-group select {
+            width: 100%;
+            padding: 10px 12px;
+            border: 1px solid #cbd5f5;
+            border-radius: 8px;
+            font-size: 14px;
+            transition: border-color 0.2s, box-shadow 0.2s;
+        }
+        .form-group textarea {
+            min-height: 110px;
+            resize: vertical;
+        }
+        .form-group input:focus,
+        .form-group textarea:focus,
+        .form-group select:focus {
+            outline: none;
+            border-color: #6366f1;
+            box-shadow: 0 0 0 3px rgba(99, 102, 241, 0.1);
+        }
+        details.stable-advanced {
+            margin-top: 10px;
+            border: 1px solid #cbd5f5;
+            border-radius: 10px;
+            padding: 12px;
+        }
+        details.stable-advanced summary {
+            cursor: pointer;
+            font-weight: 600;
+            color: #1d4ed8;
+        }
+        .stable-advanced-grid {
+            margin-top: 12px;
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+            gap: 12px;
+        }
+        .stable-switch {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 13px;
+        }
+        .stable-switch input {
+            width: auto;
+        }
+        .stable-logs {
+            margin-top: 18px;
+        }
+        .stable-logs pre {
+            background: #0f172a;
+            color: #cbd5f5;
+            border-radius: 8px;
+            padding: 14px;
+            font-size: 12px;
+            max-height: 220px;
+            overflow: auto;
+        }
+        .btn.primary {
+            background: linear-gradient(120deg, #6366f1, #8b5cf6);
+            border: none;
+            color: #fff;
+            border-radius: 10px;
+            padding: 10px 18px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: transform 0.15s ease, box-shadow 0.2s ease;
+        }
+        .btn.primary:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+            box-shadow: none;
+        }
+        .btn.primary:not(:disabled):hover {
+            transform: translateY(-2px);
+            box-shadow: 0 10px 20px rgba(99, 102, 241, 0.2);
+        }
+        .btn.secondary {
+            background: #e2e8f0;
+            border: none;
+            color: #0f172a;
+            border-radius: 8px;
+            padding: 8px 14px;
+            font-weight: 600;
+            cursor: pointer;
+        }
+        .stable-inline {
+            display: flex;
+            gap: 10px;
+            align-items: center;
+        }
+        @media (max-width: 1200px) {
+            .stable-signer-root {
+                flex-direction: column;
+            }
+        }
+    `;
+    document.head.appendChild(style);
+}
+
+export default class StableSignerPlugin extends ControlWavePlugin {
+    constructor() {
+        super({
+            id: 'stable-signer',
+            name: 'StableSigner',
+            version: '1.0.0',
+            author: 'StableSigner',
+            description: 'Prompt/Text → Gloss → Pose Video',
+            order: 25,
+            needsViser: false
+        });
+        this.state = {
+            status: 'Idle',
+            lastVideo: null
+        };
+        this.currentVideoObjectUrl = null;
+    }
+
+    async render(container) {
+        ensureStyles();
+        this.container = container;
+        container.classList.add('tab-content', 'active');
+        container.style.display = 'flex';
+        container.innerHTML = this.renderTemplate();
+        this.cacheElements(container);
+        this.attachEvents();
+        this.updateStatus('Idle');
+        await this.refreshRecentVideos();
+    }
+
+    renderTemplate() {
+        return `
+            <div class="stable-signer-root">
+                <div class="stable-signer-left">
+                    <div class="stable-video-frame">
+                        <video id="stable-video" controls playsinline loop muted></video>
+                        <div id="stable-video-placeholder" class="stable-video-placeholder">
+                            生成的 pose 视频将显示在这里
+                        </div>
+                    </div>
+                    <div class="stable-video-controls">
+                        <select id="stable-video-select">
+                            <option value="">选择最近生成的视频</option>
+                        </select>
+                        <button id="stable-video-refresh" class="btn secondary">刷新</button>
+                    </div>
+                    <div class="stable-meta" id="stable-video-meta">
+                        等待生成视频...
+                    </div>
+                </div>
+                <div class="stable-signer-right">
+                    <div class="stable-control-header">
+                        <button id="stable-generate" class="btn primary">生成 Pose Video</button>
+                        <span class="stable-status-chip" id="stable-status">Idle</span>
+                    </div>
+                    <div class="stable-form-row">
+                        <div class="form-group">
+                            <label>Prompt (可选)</label>
+                            <textarea id="stable-prompt" placeholder="描述你想要的动作或指令..."></textarea>
+                        </div>
+                        <div class="form-group">
+                            <label>Text / Context</label>
+                            <textarea id="stable-text" placeholder="输入完整的句子或上下文"></textarea>
+                        </div>
+                    </div>
+                    <div class="form-group">
+                        <label>Gloss 序列（自动生成，可手动编辑）</label>
+                        <textarea id="stable-gloss" placeholder="示例：YOU WANT DRINK WATER"></textarea>
+                        <div class="form-group" style="margin-top:8px;font-size:13px;color:#475569;">
+                            <div>示例：</div>
+                            <div>1. HELLO WORLD</div>
+                            <div>2. YOU WANT DRINK WATER</div>
+                            <div>3. TODAY WEATHER NICE</div>
+                            <div>4. I GO SCHOOL LATER</div>
+                        </div>
+                    </div>
+                    <div class="form-group">
+                        <label>复用已有视频（路径或文件名，可选）</label>
+                        <input id="stable-existing-video" type="text" placeholder="如：generated_pose_video/EXAMPLE.mp4">
+                    </div>
+                    <details class="stable-advanced">
+                        <summary>高级设置</summary>
+                        <div class="stable-advanced-grid">
+                            <div class="form-group">
+                                <label>FPS</label>
+                                <input id="stable-fps" type="number" min="5" max="60" value="30">
+                            </div>
+                            <div class="form-group">
+                                <label>宽度</label>
+                                <input id="stable-width" type="number" min="256" max="1024" value="480">
+                            </div>
+                            <div class="form-group">
+                                <label>高度</label>
+                                <input id="stable-height" type="number" min="256" max="1024" value="480">
+                            </div>
+                            <div class="form-group">
+                                <label>Smoothing</label>
+                                <select id="stable-smoothing">
+                                    <option value="none">None</option>
+                                    <option value="fade">Fade</option>
+                                    <option value="blend">Blend</option>
+                                    <option value="pause">Pause</option>
+                                </select>
+                            </div>
+                            <div class="form-group">
+                                <label>Smoothing Frames</label>
+                                <input id="stable-smoothing-frames" type="number" min="0" max="60" value="5">
+                            </div>
+                            <div class="form-group">
+                                <label>NPZ Interp Frames</label>
+                                <input id="stable-npz" type="number" min="0" max="60" value="0">
+                            </div>
+                            <div class="form-group">
+                                <label>Scale X</label>
+                                <input id="stable-scale-x" type="number" step="0.1" value="1.5">
+                            </div>
+                            <div class="form-group">
+                                <label>Scale Y</label>
+                                <input id="stable-scale-y" type="number" step="0.1" value="1.5">
+                            </div>
+                            <div class="form-group">
+                                <label>Draw Style</label>
+                                <select id="stable-draw-style">
+                                    <option value="controlnext">ControlNeXt</option>
+                                    <option value="openpose">OpenPose</option>
+                                </select>
+                            </div>
+                            <div class="form-group">
+                                <label>Max Candidates</label>
+                                <input id="stable-max-candidates" type="number" min="0" value="10">
+                            </div>
+                            <div class="form-group">
+                                <label>Max New Tokens</label>
+                                <input id="stable-max-new" type="number" min="8" max="256" value="64">
+                            </div>
+                            <div class="form-group">
+                                <label>参考图像路径 (可选)</label>
+                                <input id="stable-ref-image" type="text" placeholder="ref_img_dict/example.png">
+                            </div>
+                            <label class="stable-switch">
+                                <input type="checkbox" id="stable-normalize" checked>
+                                归一化姿态
+                            </label>
+                            <label class="stable-switch">
+                                <input type="checkbox" id="stable-hide-torso">
+                                隐藏躯干线
+                            </label>
+                        </div>
+                    </details>
+                    <div class="stable-logs">
+                        <label>日志输出</label>
+                        <pre id="stable-logs">(等待任务...)</pre>
+                    </div>
+                </div>
+            </div>
+        `;
+    }
+
+    cacheElements(container) {
+        this.videoEl = container.querySelector('#stable-video');
+        this.videoPlaceholder = container.querySelector('#stable-video-placeholder');
+        this.videoSelect = container.querySelector('#stable-video-select');
+        this.videoRefreshBtn = container.querySelector('#stable-video-refresh');
+        this.videoMeta = container.querySelector('#stable-video-meta');
+        this.generateBtn = container.querySelector('#stable-generate');
+        this.statusChip = container.querySelector('#stable-status');
+        this.promptInput = container.querySelector('#stable-prompt');
+        this.textInput = container.querySelector('#stable-text');
+        this.glossInput = container.querySelector('#stable-gloss');
+        this.existingInput = container.querySelector('#stable-existing-video');
+        this.fpsInput = container.querySelector('#stable-fps');
+        this.widthInput = container.querySelector('#stable-width');
+        this.heightInput = container.querySelector('#stable-height');
+        this.smoothingSelect = container.querySelector('#stable-smoothing');
+        this.smoothingFramesInput = container.querySelector('#stable-smoothing-frames');
+        this.npzInput = container.querySelector('#stable-npz');
+        this.scaleXInput = container.querySelector('#stable-scale-x');
+        this.scaleYInput = container.querySelector('#stable-scale-y');
+        this.drawStyleSelect = container.querySelector('#stable-draw-style');
+        this.maxCandidatesInput = container.querySelector('#stable-max-candidates');
+        this.maxNewTokensInput = container.querySelector('#stable-max-new');
+        this.refImageInput = container.querySelector('#stable-ref-image');
+        this.normalizeCheckbox = container.querySelector('#stable-normalize');
+        this.hideTorsoCheckbox = container.querySelector('#stable-hide-torso');
+        this.logsPre = container.querySelector('#stable-logs');
+        if (this.videoEl) {
+            this.videoEl.style.display = 'none';
+        }
+    }
+
+    attachEvents() {
+        this.generateBtn.addEventListener('click', () => this.handleGenerate());
+        this.videoRefreshBtn.addEventListener('click', () => this.refreshRecentVideos());
+        this.videoSelect.addEventListener('change', () => this.handleRecentSelection());
+
+        window.addEventListener('websocket-connected', () => {
+            this.updateStatus('WebSocket connected');
+        });
+
+        this.glossInput.addEventListener('input', () => {
+            const { selectionStart, selectionEnd, value } = this.glossInput;
+            const upper = value.toUpperCase();
+            if (upper !== value) {
+                this.glossInput.value = upper;
+                this.glossInput.setSelectionRange(selectionStart, selectionEnd);
+            }
+        });
+    }
+
+    collectPayload() {
+        const glossValue = (this.glossInput.value || '').toUpperCase().replace(/\s+/g, ' ').trim();
+        return {
+            prompt: this.promptInput.value,
+            text: this.textInput.value,
+            gloss: glossValue,
+            existingVideo: this.existingInput.value,
+            fps: toInt(this.fpsInput.value, 30),
+            width: toInt(this.widthInput.value, 480),
+            height: toInt(this.heightInput.value, 480),
+            smoothing: this.smoothingSelect.value,
+            smoothingFrames: toInt(this.smoothingFramesInput.value, 5),
+            npzInterpolation: toInt(this.npzInput.value, 0),
+            scaleX: toFloat(this.scaleXInput.value, 1.5),
+            scaleY: toFloat(this.scaleYInput.value, 1.5),
+            drawStyle: this.drawStyleSelect.value,
+            maxCandidates: toInt(this.maxCandidatesInput.value, 10),
+            maxNewTokens: toInt(this.maxNewTokensInput.value, 64),
+            refImagePath: this.refImageInput.value,
+            normalizePose: this.normalizeCheckbox.checked,
+            hideTorsoLines: this.hideTorsoCheckbox.checked
+        };
+    }
+
+    async handleGenerate() {
+        if (!window.controlWaveWebSocket || !window.controlWaveWebSocket.sendRequest) {
+            this.updateStatus('WebSocket 未就绪');
+            return;
+        }
+        const payload = this.collectPayload();
+        this.setLoading(true);
+        this.updateStatus('Running...');
+        try {
+            const response = await window.controlWaveWebSocket.sendRequest(this.id, {
+                action: 'generate_pose',
+                data: payload
+            });
+            console.log('[StableSigner] generation payload', response);
+            const normalizedStatus = typeof response.status === 'string' ? response.status.toLowerCase() : '';
+            const inferredSuccess = normalizedStatus === 'success' || (!!response.video_url && response.generated !== undefined);
+            if (inferredSuccess) {
+                if (response.gloss) {
+                    this.glossInput.value = response.gloss;
+                }
+                if (response.video_url) {
+                    await this.updateVideo(response.video_url, response.video_path);
+                }
+                if (response.logs) {
+                    this.logsPre.textContent = response.logs;
+                }
+                this.updateStatus(response.generated ? 'Generation completed' : 'Reused existing video');
+                try {
+                    await this.refreshRecentVideos();
+                } catch (err) {
+                    console.warn('[StableSigner] refresh failed', err);
+                }
+            } else {
+                console.error('[StableSigner] backend returned error', response);
+                this.updateStatus('Error');
+                this.logsPre.textContent = response.logs 
+                    || response.message 
+                    || response.error 
+                    || normalizedStatus 
+                    || 'Unknown error';
+            }
+        } catch (error) {
+            this.updateStatus('Error');
+            console.error('[StableSigner] request failure', error);
+            this.logsPre.textContent = (error && error.message) ? error.message : 'Request failed';
+        } finally {
+            this.setLoading(false);
+        }
+    }
+
+    async updateVideo(url, path) {
+        if (!url || !this.videoEl) return;
+        const absoluteUrl = url.startsWith('http') ? url : `${window.location.origin}${url}`;
+        const hasQuery = absoluteUrl.includes('?');
+        const fetchUrl = `${absoluteUrl}${hasQuery ? '&' : '?'}t=${Date.now()}`;
+
+        const resetVideoEl = () => {
+            this.videoEl.onloadeddata = null;
+            this.videoEl.onerror = null;
+            this.videoEl.pause();
+            this.videoEl.removeAttribute('src');
+            this.videoEl.load();
+        };
+
+        this.videoPlaceholder.style.display = 'flex';
+        this.videoPlaceholder.textContent = '正在加载视频…';
+        this.videoEl.style.display = 'none';
+        resetVideoEl();
+
+        if (this.currentVideoObjectUrl) {
+            URL.revokeObjectURL(this.currentVideoObjectUrl);
+            this.currentVideoObjectUrl = null;
+        }
+
+        try {
+            const response = await fetch(fetchUrl, { cache: 'no-store' });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+
+            const blob = await response.blob();
+            const objectUrl = URL.createObjectURL(blob);
+            this.currentVideoObjectUrl = objectUrl;
+
+            this.videoEl.onloadeddata = () => {
+                this.videoEl.onloadeddata = null;
+                this.videoEl.onerror = null;
+                this.videoPlaceholder.style.display = 'none';
+                this.videoEl.style.display = 'block';
+                const playPromise = this.videoEl.play();
+                if (playPromise && typeof playPromise.catch === 'function') {
+                    playPromise.catch(() => {});
+                }
+                this.videoMeta.textContent = `视频: ${path || absoluteUrl}`;
+            };
+
+            this.videoEl.onerror = () => {
+                this.videoEl.onloadeddata = null;
+                this.videoEl.onerror = null;
+                this.videoPlaceholder.style.display = 'flex';
+                this.videoPlaceholder.textContent = '视频加载失败';
+                const mediaError = this.videoEl.error;
+                console.error('[StableSigner] video load error', mediaError ? {
+                    code: mediaError.code,
+                    message: mediaError.message
+                } : 'unknown');
+            };
+
+            this.videoEl.src = objectUrl;
+            this.videoEl.load();
+        } catch (error) {
+            resetVideoEl();
+            this.videoPlaceholder.style.display = 'flex';
+            this.videoPlaceholder.textContent = '视频加载失败';
+            console.error('[StableSigner] video fetch failed', error);
+        }
+    }
+
+    async refreshRecentVideos() {
+        if (!window.controlWaveWebSocket || !window.controlWaveWebSocket.sendRequest) {
+            this.updateStatus('等待 WebSocket...');
+            return;
+        }
+        try {
+            const response = await window.controlWaveWebSocket.sendRequest(this.id, {
+                action: 'list_recent_videos'
+            });
+            this.populateRecentVideos(response.videos || []);
+        } catch (error) {
+            this.videoMeta.textContent = `无法刷新视频列表: ${error.message}`;
+        }
+    }
+
+    populateRecentVideos(videos) {
+        this.videoSelect.innerHTML = '<option value="">选择最近生成的视频</option>';
+        videos.forEach(video => {
+            const option = document.createElement('option');
+            option.value = video.url;
+            option.dataset.path = video.path;
+            option.dataset.size = video.size_mb;
+            option.textContent = `${video.name} (${video.size_mb} MB)`;
+            this.videoSelect.appendChild(option);
+        });
+    }
+
+    async handleRecentSelection() {
+        const option = this.videoSelect.selectedOptions[0];
+        if (!option || !option.value) {
+            return;
+        }
+        this.videoMeta.textContent = `${option.dataset.path} • ${option.dataset.size} MB`;
+        await this.updateVideo(option.value, option.dataset.path);
+    }
+
+    setLoading(isLoading) {
+        this.generateBtn.disabled = isLoading;
+        this.generateBtn.textContent = isLoading ? '生成中...' : '生成 Pose Video';
+    }
+
+    updateStatus(text) {
+        this.statusChip.textContent = text;
+    }
+}

viser_backend.py

@@ -0,0 +1,371 @@
+#!/usr/bin/env python3
+"""
+StableSigner plugin backend
+Handles prompt/text -> gloss -> pose video generation for the ControlWorld panel.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import io
+import threading
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# ControlWorld provides plugin_base in the parent directory of every plugin
+import sys
+
+PLUGIN_DIR = Path(__file__).resolve().parent
+
+def _inject_plugin_base_path():
+    candidates = [
+        PLUGIN_DIR.parent,  # actual repo root
+        PLUGIN_DIR.parent / "ControlWorld" / "plugins",
+        Path(__file__).resolve().parent.parent,  # fallback two-level parent
+    ]
+    for candidate in candidates:
+        plugin_base_file = candidate / "plugin_base.py"
+        if plugin_base_file.exists():
+            candidate_str = str(candidate)
+            if candidate_str not in sys.path:
+                sys.path.append(candidate_str)
+            return
+
+_inject_plugin_base_path()
+
+if str(PLUGIN_DIR) not in sys.path:
+    sys.path.append(str(PLUGIN_DIR))
+
+from plugin_base import PluginBackendBase  # type: ignore  # pylint: disable=wrong-import-position
+
+# Import local helpers lazily when needed
+from prompt2gloss import build_input as build_prompt_input  # type: ignore
+
+
+def _to_bool(value: Any, default: bool = False) -> bool:
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return default
+    if isinstance(value, str):
+        return value.strip().lower() in {"1", "true", "yes", "on"}
+    return bool(value)
+
+
+def _safe_int(value: Any, default: int) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def _safe_float(value: Any, default: float) -> float:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return default
+
+
+@dataclass
+class VideoInfo:
+    path: Path
+    url: str
+
+
+class StableSignerBackend(PluginBackendBase):
+    """Backend logic for StableSigner tab (no Viser visualization required)."""
+
+    def __init__(self, server):
+        super().__init__(server)
+        self.name = "stable-signer"
+        self.display_name = "StableSigner"
+        self.plugin_root = PLUGIN_DIR
+        self.web_base_url = f"/plugins/{self.plugin_root.name}"
+        self.output_dir = self.plugin_root / "generated_pose_video"
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        self._prompt_tokenizer = None
+        self._prompt_model = None
+        self._prompt_device = None
+        self._prompt_lock = threading.Lock()
+        self._torch = None
+        self._qa_instances: Dict[int, SignLanguageQA] = {}
+        self._generation_lock = threading.Lock()
+
+    # ------------------------------------------------------------------
+    # Lazy loaders
+    # ------------------------------------------------------------------
+    def _load_prompt_model(self):
+        if self._prompt_model is not None:
+            return
+
+        model_dir = self.plugin_root / "prompt2gloss" / "t5_finetuned"
+        if not model_dir.exists():
+            raise FileNotFoundError(
+                f"Prompt2Gloss checkpoint not found at {model_dir}. "
+                "Please train or copy the fine-tuned weights."
+            )
+
+        with self._prompt_lock:
+            if self._prompt_model is not None:
+                return
+
+            from transformers import AutoTokenizer, AutoModelForSeq2SeqLM  # lazy import
+            import torch
+
+            self._prompt_tokenizer = AutoTokenizer.from_pretrained(model_dir)
+            self._prompt_model = AutoModelForSeq2SeqLM.from_pretrained(model_dir)
+            self._torch = torch
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            self._prompt_device = device
+            self._prompt_model.to(device)
+            self._prompt_model.eval()
+
+    def _get_prompt_model(self):
+        self._load_prompt_model()
+        return self._prompt_tokenizer, self._prompt_model, self._prompt_device, self._torch
+
+    def _get_qa_system(self, max_candidates: int) -> SignLanguageQA:
+        from gloss2pose import SignLanguageQA  # type: ignore  # local import
+
+        key = max_candidates if max_candidates >= 0 else 10
+        if key not in self._qa_instances:
+            self._qa_instances[key] = SignLanguageQA(max_candidates=key)
+        return self._qa_instances[key]
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+    def _format_logs(self, buffer: io.StringIO) -> str:
+        text = buffer.getvalue().strip()
+        return text if text else "(no logs)"
+
+    def _to_web_url(self, file_path: Path) -> Optional[str]:
+        try:
+            rel = file_path.relative_to(self.plugin_root)
+            return f"{self.web_base_url}/{rel.as_posix()}"
+        except ValueError:
+            return None
+
+    def _resolve_existing_video(self, user_value: str) -> Optional[VideoInfo]:
+        if not user_value:
+            return None
+
+        candidates = []
+        user_path = Path(user_value.strip())
+        candidates.append(user_path)
+        candidates.append(self.output_dir / user_path.name)
+        candidates.append(self.plugin_root / user_path)
+
+        for candidate in candidates:
+            if candidate.exists() and candidate.is_file():
+                url = self._to_web_url(candidate)
+                if url is None:
+                    continue
+                return VideoInfo(path=candidate, url=url)
+        return None
+
+    def _generate_gloss(self, text: str, prompt: Optional[str], max_new_tokens: int) -> str:
+        tokenizer, model, device, torch = self._get_prompt_model()
+        prompt_text = prompt.strip() if prompt else text.strip()
+        if not prompt_text:
+            raise ValueError("Prompt/text input is empty.")
+        input_text = build_prompt_input(prompt_text, text)
+        encoded = tokenizer(
+            input_text,
+            return_tensors="pt",
+            truncation=True,
+            max_length=512,
+        ).to(device)
+        with torch.no_grad():
+            outputs = model.generate(
+                **encoded,
+                max_new_tokens=max_new_tokens,
+                num_beams=4,
+                length_penalty=1.0,
+                early_stopping=True,
+            )
+        decoded = tokenizer.batch_decode(outputs, skip_special_tokens=True)[0].strip().upper()
+        return decoded
+
+    def _build_output_path(self, gloss_tokens: List[str], draw_style: str) -> Path:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        slug = "_".join(gloss_tokens[:4]) if gloss_tokens else "gloss"
+        suffix = f"_{draw_style}_style" if draw_style else ""
+        filename = f"{slug}_{timestamp}{suffix}.mp4"
+        return self.output_dir / filename
+
+    def _list_recent_videos(self, limit: int = 12) -> List[Dict[str, Any]]:
+        if not self.output_dir.exists():
+            return []
+        videos = sorted(
+            [p for p in self.output_dir.glob("*.mp4") if p.is_file()],
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )
+        result = []
+        for video in videos[:limit]:
+            url = self._to_web_url(video)
+            if not url:
+                continue
+            result.append(
+                {
+                    "name": video.name,
+                    "url": url,
+                    "path": str(video),
+                    "updated": datetime.fromtimestamp(video.stat().st_mtime).isoformat(),
+                    "size_mb": round(video.stat().st_size / (1024 * 1024), 2),
+                }
+            )
+        return result
+
+    # ------------------------------------------------------------------
+    # Message handling
+    # ------------------------------------------------------------------
+    def handle_message(self, message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        action = message.get("action")
+        data = message.get("data", {}) or {}
+
+        if action == "generate_pose":
+            return self.handle_generate_pose(data)
+        if action == "list_recent_videos":
+            return {"status": "success", "videos": self._list_recent_videos()}
+        if action == "probe_video":
+            return self.handle_probe_video(data)
+        return super().handle_message(message)
+
+    def handle_probe_video(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        candidate = (data.get("path") or "").strip()
+        info = self._resolve_existing_video(candidate)
+        if info:
+            return {
+                "status": "success",
+                "video": {
+                    "name": info.path.name,
+                    "url": info.url,
+                    "path": str(info.path),
+                    "size_mb": round(info.path.stat().st_size / (1024 * 1024), 2),
+                },
+            }
+        return {"status": "error", "message": "Video not found or outside plugin directory."}
+
+    def handle_generate_pose(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        if not self._generation_lock.acquire(blocking=False):
+            return {"status": "error", "message": "A generation job is already running. Please wait."}
+
+        try:
+            text_input = (data.get("text") or "").strip()
+            prompt_input = (data.get("prompt") or "").strip()
+            gloss_input = (data.get("gloss") or "").strip()
+            max_new_tokens = _safe_int(data.get("maxNewTokens"), 64)
+
+            # Allow reusing an existing video without regeneration
+            reuse_target = (data.get("existingVideo") or "").strip()
+            if reuse_target:
+                info = self._resolve_existing_video(reuse_target)
+                if not info:
+                    return {"status": "error", "message": "Specified video path/name not found."}
+                return {
+                    "status": "success",
+                    "gloss": gloss_input.upper(),
+                    "video_url": info.url,
+                    "video_path": str(info.path),
+                    "logs": f"Reused existing video: {info.path.name}",
+                    "generated": False,
+                }
+
+            if not gloss_input:
+                if not text_input:
+                    return {"status": "error", "message": "Please enter text/prompt or a gloss sequence."}
+                gloss_input = self._generate_gloss(text_input, prompt_input, max_new_tokens)
+
+            gloss_tokens = [token for token in gloss_input.upper().split() if token]
+            if not gloss_tokens:
+                return {"status": "error", "message": "Gloss string is empty after normalization."}
+
+            fps = _safe_int(data.get("fps"), 30)
+            width = _safe_int(data.get("width"), 480)
+            height = _safe_int(data.get("height"), 480)
+            smoothing_method = data.get("smoothing", "none") or "none"
+            smoothing_frames = _safe_int(data.get("smoothingFrames"), 5)
+            npz_interp = _safe_int(data.get("npzInterpolation"), 0)
+            scale_x = _safe_float(data.get("scaleX"), 1.5)
+            scale_y = _safe_float(data.get("scaleY"), 1.5)
+            hide_torso = _to_bool(data.get("hideTorsoLines"), False)
+            normalize_pose = _to_bool(data.get("normalizePose"), True)
+            draw_style = (data.get("drawStyle") or "controlnext").lower()
+            max_candidates = _safe_int(data.get("maxCandidates"), 10)
+            ref_image = (data.get("refImagePath") or "").strip() or None
+
+            qa_system = self._get_qa_system(max_candidates if max_candidates >= 0 else 10)
+            output_path = self._build_output_path(gloss_tokens, draw_style)
+
+            log_buffer = io.StringIO()
+            success = False
+            with contextlib.redirect_stdout(log_buffer), contextlib.redirect_stderr(log_buffer):
+                success = qa_system.generate_video_from_glosses(
+                    gloss_tokens,
+                    output_path,
+                    fps=fps,
+                    width=width,
+                    height=height,
+                    smoothing_frames=smoothing_frames,
+                    smoothing_method=smoothing_method,
+                    npz_interpolation_frames=npz_interp,
+                    scale_x=scale_x,
+                    scale_y=scale_y,
+                    hide_torso_lines=hide_torso,
+                    ref_image_path=ref_image,
+                    draw_style=draw_style,
+                    normalize_pose=normalize_pose,
+                )
+
+            logs = self._format_logs(log_buffer)
+
+            if not success or not output_path.exists():
+                return {
+                    "status": "error",
+                    "message": "Video generation failed. See logs for details.",
+                    "logs": logs,
+                }
+
+            url = self._to_web_url(output_path)
+            if not url:
+                return {
+                    "status": "error",
+                    "message": "Video generated but cannot be served (outside plugin directory).",
+                    "logs": logs,
+                }
+
+            return {
+                "status": "success",
+                "gloss": " ".join(gloss_tokens),
+                "video_url": url,
+                "video_path": str(output_path),
+                "logs": logs,
+                "generated": True,
+                "settings": {
+                    "fps": fps,
+                    "width": width,
+                    "height": height,
+                    "smoothing": smoothing_method,
+                    "npzInterpolation": npz_interp,
+                    "drawStyle": draw_style,
+                },
+            }
+        except Exception as exc:  # pylint: disable=broad-except
+            log = io.StringIO()
+            with contextlib.redirect_stdout(log), contextlib.redirect_stderr(log):
+                import traceback
+
+                traceback.print_exc()
+            logs = log.getvalue()
+            return {"status": "error", "message": str(exc), "logs": logs}
+        finally:
+            self._generation_lock.release()
+
+
+# Entry point required by ControlWorld's loader
+PluginBackend = StableSignerBackend