Upload clashcr/core/capture.py with huggingface_hub

clashcr/core/capture.py

@@ -0,0 +1,279 @@
+"""Emulator screen capture supporting MuMu Player and BlueStacks on Windows.
+
+Handles:
+- Dynamic window detection by class name / title
+- Exact client-area capture (excluding borders/title bar)
+- DPI scaling, resize, moved windows, negative monitor coordinates
+- Raw screenshot saving for debugging
+"""
+from __future__ import annotations
+
+import logging
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Tuple
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+# Platform-specific imports
+if os.name == "nt":
+    import win32gui
+    import win32ui
+    import win32con
+    from ctypes import windll
+else:
+    win32gui = None  # type: ignore
+
+
+@dataclass
+class WindowInfo:
+    hwnd: int
+    title: str
+    class_name: str
+    left: int
+    top: int
+    width: int
+    height: int
+    client_left: int
+    client_top: int
+    client_width: int
+    client_height: int
+    dpi_scale: float
+    is_minimized: bool
+
+
+class EmulatorCapture:
+    """Capture emulator windows on Windows using Win32 API."""
+
+    # Common emulator window class names and title substrings
+    EMULATOR_SIGNATURES = [
+        ("Qt5QWindowIcon", "MuMu"),      # MuMu Player
+        ("Qt5QWindowIcon", "Nemu"),      # Nemu (MuMu variant)
+        ("BlueStacksApp", "BlueStacks"), # BlueStacks
+        ("_ctl.Window", "BlueStacks"),   # BlueStacks alternative
+        ("RenderWindow", None),          # Generic render window
+    ]
+
+    def __init__(self, target_title_substring: Optional[str] = None,
+                 target_class_name: Optional[str] = None,
+                 fallback_monitor: Optional[dict] = None):
+        self.target_title = target_title_substring
+        self.target_class = target_class_name
+        self.fallback_monitor = fallback_monitor
+        self._last_hwnd: Optional[int] = None
+        self._last_info: Optional[WindowInfo] = None
+
+    def _enum_windows(self) -> list:
+        if win32gui is None:
+            return []
+        results = []
+        def callback(hwnd, extra):
+            if win32gui.IsWindow(hwnd) and win32gui.IsWindowEnabled(hwnd):
+                try:
+                    title = win32gui.GetWindowText(hwnd)
+                    class_name = win32gui.GetClassName(hwnd)
+                    results.append((hwnd, title, class_name))
+                except Exception:
+                    pass
+            return True
+        win32gui.EnumWindows(callback, None)
+        return results
+
+    def find_window(self) -> Optional[WindowInfo]:
+        if win32gui is None:
+            logger.warning("Win32 API not available; running on non-Windows platform.")
+            return None
+
+        candidates = self._enum_windows()
+        best = None
+        best_score = 0
+
+        for hwnd, title, class_name in candidates:
+            score = 0
+            if self.target_title and self.target_title.lower() in title.lower():
+                score += 10
+            if self.target_class and self.target_class.lower() == class_name.lower():
+                score += 10
+
+            # Heuristic matching
+            for sig_class, sig_title in self.EMULATOR_SIGNATURES:
+                if class_name == sig_class:
+                    score += 5
+                if sig_title and sig_title.lower() in title.lower():
+                    score += 5
+
+            if score > best_score:
+                best = (hwnd, title, class_name)
+                best_score = score
+
+        if best is None:
+            return None
+
+        hwnd, title, class_name = best
+        self._last_hwnd = hwnd
+        info = self._get_window_info(hwnd)
+        self._last_info = info
+        return info
+
+    def _get_window_info(self, hwnd: int) -> WindowInfo:
+        rect = win32gui.GetWindowRect(hwnd)
+        left, top, right, bottom = rect
+        width = right - left
+        height = bottom - top
+
+        # Client area
+        client_left, client_top, client_right, client_bottom = win32gui.GetClientRect(hwnd)
+        # Map client rect to screen coords
+        pt = win32gui.ClientToScreen(hwnd, (client_left, client_top))
+        client_left_scr, client_top_scr = pt
+        client_width = client_right - client_left
+        client_height = client_bottom - client_top
+
+        # DPI scale
+        try:
+            dpi = windll.user32.GetDpiForWindow(hwnd)
+            dpi_scale = dpi / 96.0
+        except Exception:
+            dpi_scale = 1.0
+
+        is_minimized = win32gui.IsIconic(hwnd)
+
+        return WindowInfo(
+            hwnd=hwnd,
+            title=win32gui.GetWindowText(hwnd),
+            class_name=win32gui.GetClassName(hwnd),
+            left=left,
+            top=top,
+            width=width,
+            height=height,
+            client_left=client_left_scr,
+            client_top=client_top_scr,
+            client_width=client_width,
+            client_height=client_height,
+            dpi_scale=dpi_scale,
+            is_minimized=is_minimized,
+        )
+
+    def capture(self, save_raw_path: Optional[str] = None) -> Optional[np.ndarray]:
+        """Capture the emulator window and return BGR numpy array."""
+        if win32gui is None:
+            return self._capture_fallback()
+
+        info = self.find_window()
+        if info is None:
+            logger.warning("No emulator window found.")
+            return None
+
+        if info.is_minimized:
+            logger.warning("Emulator window is minimized.")
+            return None
+
+        hwnd = info.hwnd
+        # Capture client area
+        w, h = info.client_width, info.client_height
+        if w <= 0 or h <= 0:
+            logger.warning("Invalid client area size.")
+            return None
+
+        hwndDC = win32gui.GetWindowDC(hwnd)
+        mfcDC = win32ui.CreateDCFromHandle(hwndDC)
+        saveDC = mfcDC.CreateCompatibleDC()
+
+        saveBitMap = win32ui.CreateBitmap()
+        saveBitMap.CreateCompatibleBitmap(mfcDC, w, h)
+        saveDC.SelectObject(saveBitMap)
+
+        # PrintWindow: PW_RENDERFULLCONTENT = 0x00000002
+        result = windll.user32.PrintWindow(hwnd, saveDC.GetSafeHdc(), 3)
+        if result == 0:
+            # Fallback to BitBlt
+            saveDC.BitBlt((0, 0), (w, h), mfcDC, (0, 0), win32con.SRCCOPY)
+
+        bmpinfo = saveBitMap.GetInfo()
+        bmpstr = saveBitMap.GetBitmapBits(True)
+
+        img = np.frombuffer(bmpstr, dtype=np.uint8)
+        img.shape = (h, w, 4)  # BGRA
+        img = img[:, :, :3]  # BGR
+
+        win32gui.DeleteObject(saveBitMap.GetHandle())
+        saveDC.DeleteDC()
+        mfcDC.DeleteDC()
+        win32gui.ReleaseDC(hwnd, hwndDC)
+
+        if save_raw_path:
+            Path(save_raw_path).parent.mkdir(parents=True, exist_ok=True)
+            import cv2
+            cv2.imwrite(save_raw_path, img)
+            logger.debug("Saved raw screenshot to %s", save_raw_path)
+
+        return img
+
+    def _capture_fallback(self) -> Optional[np.ndarray]:
+        """Non-Windows fallback using mss."""
+        try:
+            import mss
+            import cv2
+        except ImportError:
+            logger.error("mss and opencv-python required for non-Windows capture.")
+            return None
+
+        sct = mss.mss()
+        monitor = self.fallback_monitor or sct.monitors[1]
+        img = np.array(sct.grab(monitor))
+        img = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
+        return img
+
+    def get_info(self) -> Optional[WindowInfo]:
+        if self._last_info is None:
+            return self.find_window()
+        return self._last_info
+
+
+class MockCapture:
+    """Capture from a video file or image sequence for testing."""
+
+    def __init__(self, source_path: str):
+        self.source_path = Path(source_path)
+        self._cap = None
+        self._frame_idx = 0
+        if self.source_path.is_file():
+            import cv2
+            self._cap = cv2.VideoCapture(str(self.source_path))
+
+    def capture(self, save_raw_path: Optional[str] = None) -> Optional[np.ndarray]:
+        if self._cap is not None:
+            ret, frame = self._cap.read()
+            self._frame_idx += 1
+            if not ret:
+                return None
+            return frame
+        return None
+
+    def release(self):
+        if self._cap is not None:
+            self._cap.release()
+
+
+def list_emulator_windows() -> list:
+    """List all windows that look like emulators."""
+    cap = EmulatorCapture()
+    all_windows = cap._enum_windows()
+    emulators = []
+    for hwnd, title, class_name in all_windows:
+        for sig_class, sig_title in EmulatorCapture.EMULATOR_SIGNATURES:
+            if class_name == sig_class or (sig_title and sig_title.lower() in title.lower()):
+                emulators.append({"hwnd": hwnd, "title": title, "class_name": class_name})
+                break
+    return emulators
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    print("Emulator windows found:")
+    for w in list_emulator_windows():
+        print(f"  hwnd={w['hwnd']} title={w['title']} class={w['class_name']}")