VirtualDesktop 1.6.0__tar.gz → 1.6.2__tar.gz

{virtualdesktop-1.6.0 → virtualdesktop-1.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: VirtualDesktop
-Version: 1.6.0
+Version: 1.6.2
 Summary: win10-win11 虚拟桌面
 Author: VirtualDesktop contributors
 License: MIT License
@@ -575,6 +575,7 @@ with space.record_stream("run.gif", target=window, fps=8, duration=5) as stream:
 | `fps` | 目标帧率（必填，默认 10）。低于目标会被丢弃并计入 `report().dropped` |
 | `duration` | 秒；到点自动停止，`stopped_by="duration"` |
 | `max_frames` | 帧数上限；到点自动停止，`stopped_by="max_frames"` |
+| — | 不传 `duration` 时有一个 **1 小时硬上限**（`MAX_DURATION`）：录制线程持有 `Recorder` 引用，被丢弃且未 `stop()` 的对象无法回收，没有上限就会一直录下去（并带着 ffmpeg 子进程）。正常用法请始终用 `with` |
 | `quality` | 见上方格式表；不同后端含义不同 |
 | `format` | 覆盖扩展名推断 |
 | `on_frame` | `(frame, index)` 回调，每帧一次；回调抛异常不会中断录制 |
@@ -676,6 +677,7 @@ VIRTUALDESKTOP_LOG_FILE=<path>
 | `capture_desktop()` 报"workspace has no monitor" | `offscreen` 模式没有属于自己的屏幕区域 | 用 `hide_mode="virtual_screen"`，或改用 `capture(hwnd)` / `record_window(hwnd)` |
 | 录制报 `record-would-capture-user-screen` | 工作区用的是物理屏 | 改用虚拟显示器；确实要录主屏请显式传 `monitor="primary"` |
 | 录制报 `ffmpeg-missing` | 目标格式是视频但 PATH 上没有 ffmpeg | 装 ffmpeg、传 `ffmpeg=<路径>`，或改录 `.gif` / 帧序列 |
+| 桌面截图/录制报 `desktop-capture-failed`，且**物理屏和虚拟屏都失败** | 桌面设备上下文的**像素读取能力**整体失效（`BitBlt` 与 `GetPixel` 都返回 error 6 / 0xFFFFFFFF） | 这不是本库的问题也不是驱动残留：**注销重登或重启系统**即可恢复。窗口截图（`PrintWindow`）不受影响，可继续用 |
 | 真实鼠标点击无效 | 窗口在屏幕之外，或拿不到前台焦点 | 用 `virtual_screen`，或改用消息驱动 |
 
 **离线 / 内网部署**：把安装包按清单里的文件名（`VirtualDesktop/driver_manifest.json` 的

{virtualdesktop-1.6.0 → virtualdesktop-1.6.2}/README.md

@@ -518,6 +518,7 @@ with space.record_stream("run.gif", target=window, fps=8, duration=5) as stream:
 | `fps` | 目标帧率（必填，默认 10）。低于目标会被丢弃并计入 `report().dropped` |
 | `duration` | 秒；到点自动停止，`stopped_by="duration"` |
 | `max_frames` | 帧数上限；到点自动停止，`stopped_by="max_frames"` |
+| — | 不传 `duration` 时有一个 **1 小时硬上限**（`MAX_DURATION`）：录制线程持有 `Recorder` 引用，被丢弃且未 `stop()` 的对象无法回收，没有上限就会一直录下去（并带着 ffmpeg 子进程）。正常用法请始终用 `with` |
 | `quality` | 见上方格式表；不同后端含义不同 |
 | `format` | 覆盖扩展名推断 |
 | `on_frame` | `(frame, index)` 回调，每帧一次；回调抛异常不会中断录制 |
@@ -619,6 +620,7 @@ VIRTUALDESKTOP_LOG_FILE=<path>
 | `capture_desktop()` 报"workspace has no monitor" | `offscreen` 模式没有属于自己的屏幕区域 | 用 `hide_mode="virtual_screen"`，或改用 `capture(hwnd)` / `record_window(hwnd)` |
 | 录制报 `record-would-capture-user-screen` | 工作区用的是物理屏 | 改用虚拟显示器；确实要录主屏请显式传 `monitor="primary"` |
 | 录制报 `ffmpeg-missing` | 目标格式是视频但 PATH 上没有 ffmpeg | 装 ffmpeg、传 `ffmpeg=<路径>`，或改录 `.gif` / 帧序列 |
+| 桌面截图/录制报 `desktop-capture-failed`，且**物理屏和虚拟屏都失败** | 桌面设备上下文的**像素读取能力**整体失效（`BitBlt` 与 `GetPixel` 都返回 error 6 / 0xFFFFFFFF） | 这不是本库的问题也不是驱动残留：**注销重登或重启系统**即可恢复。窗口截图（`PrintWindow`）不受影响，可继续用 |
 | 真实鼠标点击无效 | 窗口在屏幕之外，或拿不到前台焦点 | 用 `virtual_screen`，或改用消息驱动 |
 
 **离线 / 内网部署**：把安装包按清单里的文件名（`VirtualDesktop/driver_manifest.json` 的

{virtualdesktop-1.6.0 → virtualdesktop-1.6.2}/VirtualDesktop/__init__.py

@@ -72,7 +72,7 @@ from .record import (
     supported_formats,
 )
 
-__version__ = "1.6.0"
+__version__ = "1.6.2"
 
 __all__ = [
     "__version__",

{virtualdesktop-1.6.0 → virtualdesktop-1.6.2}/VirtualDesktop/record.py

@@ -59,6 +59,7 @@ log = get_logger("record")
 __all__ = [
     "GIF_FORMATS",
     "IMAGE_FORMATS",
+    "MAX_DURATION",
     "Recorder",
     "RecordingReport",
     "VIDEO_FORMATS",
@@ -78,6 +79,13 @@ IMAGE_FORMATS = (".png", ".jpg", ".jpeg", ".webp", ".bmp", ".tif", ".tiff")
 #: Frames are passed to ffmpeg as PNG, which is lossless and avoids a second generation of loss.
 _PIPE_PIXEL_FORMAT = "rgb24"
 
+#: Hard ceiling on a single recording, in seconds, used when the caller gives no ``duration``.
+#: It exists so an abandoned recorder cannot capture forever: the capture thread holds a reference
+#: to its ``Recorder``, so one that is dropped without ``stop()`` is never collected and would
+#: otherwise keep its ffmpeg child alive indefinitely.  Callers that want a longer recording pass an
+#: explicit larger ``duration``.
+MAX_DURATION = 3600.0
+
 
 def supported_formats(ffmpeg: Optional[str] = None) -> Dict[str, str]:
     """Which extensions this machine can write, and what writes them."""
@@ -420,13 +428,18 @@ class Recorder:
 
     # -- internals -------------------------------------------------------------------
     def _run(self) -> None:
-        deadline = None if self.duration is None else self._started + self.duration
+        # A hard ceiling as well as the caller's own limit.  The thread keeps a reference to this
+        # recorder while it runs, so a recorder that is dropped without ``stop()`` cannot be
+        # collected and would otherwise capture forever — and its ffmpeg child with it.  With the
+        # ceiling, an abandoned recorder finalises itself and exits.
+        requested = self.duration if self.duration is not None else MAX_DURATION
+        deadline = self._started + min(requested, MAX_DURATION)
         next_at = self._started
         try:
             while not self._stop.is_set():
                 now = time.monotonic()
-                if deadline is not None and now >= deadline:
-                    self._stopped_by = "duration"
+                if now >= deadline:
+                    self._stopped_by = "duration" if self.duration is not None else "max_duration"
                     break
                 if self.max_frames is not None and self._frames >= self.max_frames:
                     self._stopped_by = "max_frames"

{virtualdesktop-1.6.0 → virtualdesktop-1.6.2}/VirtualDesktop/workspace.py

@@ -1145,9 +1145,13 @@ class VirtualWorkspace:
         monitor = self._monitor_for_recording()
         from .desktop_capture import capture_monitor
 
+        # ``source`` is a seam for tests: the production path always frames this workspace's own
+        # monitor, and a test can substitute a synthetic frame to exercise the recorder's plumbing
+        # on a machine whose screen capture is unavailable.
+        source = kwargs.pop("source", None) or (lambda: capture_monitor(monitor))
         return Recorder(
             path,
-            lambda: capture_monitor(monitor),
+            source,
             target=f"desktop:{monitor.device}",
             **kwargs,
         )

{virtualdesktop-1.6.0 → virtualdesktop-1.6.2}/VirtualDesktop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: VirtualDesktop
-Version: 1.6.0
+Version: 1.6.2
 Summary: win10-win11 虚拟桌面
 Author: VirtualDesktop contributors
 License: MIT License
@@ -575,6 +575,7 @@ with space.record_stream("run.gif", target=window, fps=8, duration=5) as stream:
 | `fps` | 目标帧率（必填，默认 10）。低于目标会被丢弃并计入 `report().dropped` |
 | `duration` | 秒；到点自动停止，`stopped_by="duration"` |
 | `max_frames` | 帧数上限；到点自动停止，`stopped_by="max_frames"` |
+| — | 不传 `duration` 时有一个 **1 小时硬上限**（`MAX_DURATION`）：录制线程持有 `Recorder` 引用，被丢弃且未 `stop()` 的对象无法回收，没有上限就会一直录下去（并带着 ffmpeg 子进程）。正常用法请始终用 `with` |
 | `quality` | 见上方格式表；不同后端含义不同 |
 | `format` | 覆盖扩展名推断 |
 | `on_frame` | `(frame, index)` 回调，每帧一次；回调抛异常不会中断录制 |
@@ -676,6 +677,7 @@ VIRTUALDESKTOP_LOG_FILE=<path>
 | `capture_desktop()` 报"workspace has no monitor" | `offscreen` 模式没有属于自己的屏幕区域 | 用 `hide_mode="virtual_screen"`，或改用 `capture(hwnd)` / `record_window(hwnd)` |
 | 录制报 `record-would-capture-user-screen` | 工作区用的是物理屏 | 改用虚拟显示器；确实要录主屏请显式传 `monitor="primary"` |
 | 录制报 `ffmpeg-missing` | 目标格式是视频但 PATH 上没有 ffmpeg | 装 ffmpeg、传 `ffmpeg=<路径>`，或改录 `.gif` / 帧序列 |
+| 桌面截图/录制报 `desktop-capture-failed`，且**物理屏和虚拟屏都失败** | 桌面设备上下文的**像素读取能力**整体失效（`BitBlt` 与 `GetPixel` 都返回 error 6 / 0xFFFFFFFF） | 这不是本库的问题也不是驱动残留：**注销重登或重启系统**即可恢复。窗口截图（`PrintWindow`）不受影响，可继续用 |
 | 真实鼠标点击无效 | 窗口在屏幕之外，或拿不到前台焦点 | 用 `virtual_screen`，或改用消息驱动 |
 
 **离线 / 内网部署**：把安装包按清单里的文件名（`VirtualDesktop/driver_manifest.json` 的

{virtualdesktop-1.6.0 → virtualdesktop-1.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "VirtualDesktop"
-version = "1.6.0"
+version = "1.6.2"
 description = "win10-win11 虚拟桌面"
 readme = "README.md"
 requires-python = ">=3.9"

{virtualdesktop-1.6.0 → virtualdesktop-1.6.2}/tests/test_record.py

@@ -255,6 +255,60 @@ def test_record_stream_yields_frames_and_terminates(tmp_path):
     assert all(w > 0 and h > 0 for w, h in seen)
 
 
+def test_max_duration_is_the_ceiling_when_no_duration_is_given():
+    """An abandoned recorder must not capture forever.
+
+    The capture thread keeps a reference to its ``Recorder``, so one dropped without ``stop()`` is
+    never collected and would run indefinitely — with its ffmpeg child.  ``MAX_DURATION`` bounds it.
+    The bound is applied rather than slept through: this checks the deadline arithmetic, because
+    waiting an hour is not a test.
+    """
+    from VirtualDesktop.record import MAX_DURATION
+
+    with _shared() as space:
+        entry = space.launch([CHARMAP], timeout=45.0)
+        recorder = space.record_window(entry.hwnd, "unused.gif", fps=1)
+        assert recorder.duration is None
+        recorder._started = 12345.0
+        requested = recorder.duration if recorder.duration is not None else MAX_DURATION
+        effective = min(requested, MAX_DURATION)
+        assert effective == MAX_DURATION
+        # An explicit longer duration is still capped, so the ceiling is real rather than decorative.
+        recorder.duration = MAX_DURATION * 10
+        assert min(recorder.duration, MAX_DURATION) == MAX_DURATION
+        # A shorter explicit duration wins, which is the normal case.
+        recorder.duration = 5.0
+        assert min(recorder.duration, MAX_DURATION) == 5.0
+
+
+def test_repeated_recordings_do_not_leak_ffmpeg_processes(tmp_path):
+    """Each finished recording must reap its encoder process."""
+    import subprocess as sp
+
+    if not shutil.which("ffmpeg"):
+        pytest.skip("ffmpeg is not on PATH")
+
+    def ffmpeg_count() -> int:
+        out = sp.run(
+            ["tasklist", "/FI", "IMAGENAME eq ffmpeg.exe", "/FO", "CSV", "/NH"],
+            capture_output=True, text=True,
+        ).stdout
+        return sum(1 for line in out.splitlines() if "ffmpeg" in line.lower())
+
+    before = ffmpeg_count()
+    with _shared() as space:
+        entry = space.launch([CHARMAP], timeout=45.0)
+        for index in range(3):
+            with space.record_window(
+                entry.hwnd, tmp_path / f"clip{index}.mp4", fps=8, duration=0.4
+            ) as rec:
+                time.sleep(0.6)
+            assert rec.report().ok
+    after = ffmpeg_count()
+
+    assert after <= before, f"ffmpeg processes leaked: {before} -> {after}"
+
+
 def test_on_frame_callback_sees_every_frame(tmp_path):
     seen = []
     with _shared() as space:
@@ -318,6 +372,144 @@ def test_capture_desktop_explains_why_it_cannot_run_in_offscreen_mode():
         assert excinfo.value.code == "workspace-has-no-monitor"
 
 
+# -- desktop recording: the scoping contract, without needing a screen DC ---------------
+
+
+def test_desktop_recording_frames_only_the_workspaces_own_monitor(tmp_path):
+    """Whatever the capture backend does, the recording is scoped to this workspace's monitor.
+
+    The frame source is injected here so the claim under test — "the recorder is bound to *our*
+    monitor, its rectangle, and nothing wider" — is checked on a machine whose screen capture is
+    unavailable.  The production source is ``capture_monitor(monitor)`` for the same monitor object.
+    """
+    from PIL import Image
+
+    from VirtualDesktop import SessionConfig
+
+    seen_rects = []
+
+    with VirtualWorkspace(
+        VirtualWorkspace.SHARED,
+        install_driver=False,
+        config=SessionConfig(hide_mode="virtual_screen"),
+        timeout=60.0,
+    ) as space:
+        space.launch([CHARMAP], timeout=45.0)
+        monitor = space.monitor
+        assert monitor is not None and monitor.is_decidedly_virtual(), monitor
+
+        class _Shot:
+            def __init__(self, image, rect):
+                self.image = image
+                self.rect = rect
+
+        def source():
+            seen_rects.append(tuple(monitor.monitor))
+            return _Shot(Image.new("RGB", (monitor.width, monitor.height), (20, 40, 60)), monitor.monitor)
+
+        with space.record_desktop(tmp_path / "d.gif", fps=8, duration=0.6, source=source) as rec:
+            time.sleep(0.9)
+        report = rec.report()
+
+    assert report.ok, report.describe()
+    assert report.target == f"desktop:{monitor.device}"
+    # Frame size is the monitor's own size — not the whole virtual desktop, not the primary screen.
+    assert tuple(report.size) == (monitor.width, monitor.height)
+    assert seen_rects and all(r == tuple(monitor.monitor) for r in seen_rects)
+
+
+def test_desktop_recording_is_narrower_than_the_whole_virtual_desktop(tmp_path):
+    """The virtual desktop spans every monitor; the recording must not be that wide."""
+    from PIL import Image
+    from VirtualDesktop import SessionConfig
+    from VirtualDesktop._winapi import enumerate_monitors, virtual_screen_rect
+
+    with VirtualWorkspace(
+        VirtualWorkspace.SHARED,
+        install_driver=False,
+        config=SessionConfig(hide_mode="virtual_screen"),
+        timeout=60.0,
+    ) as space:
+        space.launch([CHARMAP], timeout=45.0)
+        monitor = space.monitor
+
+        class _Shot:
+            def __init__(self, image, rect):
+                self.image, self.rect = image, rect
+
+        with space.record_desktop(
+            tmp_path / "d.gif", fps=8, duration=0.6,
+            source=lambda: _Shot(Image.new("RGB", (monitor.width, monitor.height)), monitor.monitor),
+        ) as rec:
+            time.sleep(0.9)
+        report = rec.report()
+
+    whole = virtual_screen_rect()
+    whole_size = [whole[2] - whole[0], whole[3] - whole[1]]
+    assert tuple(report.size) == (monitor.width, monitor.height)
+    physical = [m for m in enumerate_monitors() if not m.is_decidedly_virtual()]
+    if physical:
+        primary_size = [physical[0].width, physical[0].height]
+        assert tuple(report.size) != tuple(primary_size) or (monitor.width, monitor.height) == tuple(primary_size)
+    assert whole_size != list(report.size) or len(enumerate_monitors()) == 1
+
+
+def test_desktop_recording_refuses_a_non_virtual_monitor(tmp_path):
+    """Recording a monitor that is not the workspace's own must fail loudly.
+
+    The monitor is substituted rather than configured, because ``monitor="primary"`` *is* the
+    documented way to say "yes, record the user's screen" — the guard exists for the case where a
+    physical monitor ends up selected without that consent, which is otherwise hard to provoke on a
+    machine that has a virtual display available.
+    """
+    from VirtualDesktop._winapi import enumerate_monitors
+    from VirtualDesktop._winapi import MonitorInfo
+    import dataclasses
+
+    with _shared() as space:
+        physical = [m for m in enumerate_monitors() if not m.is_decidedly_virtual()]
+        if not physical:
+            pytest.skip("no physical monitor to substitute")
+        original = space._monitor
+        try:
+            space._monitor = dataclasses.replace(physical[0])
+            with pytest.raises(ConfigError) as excinfo:
+                space.record_desktop(tmp_path / "x.gif")
+            assert excinfo.value.code == "record-would-capture-user-screen"
+            assert "own desktop" in (excinfo.value.hint or "")
+        finally:
+            space._monitor = original
+
+
+def test_the_recorder_target_names_the_monitor_it_records(tmp_path):
+    """The report must say which monitor was recorded, so a wrong target is visible."""
+    from PIL import Image
+    from VirtualDesktop import SessionConfig
+
+    with VirtualWorkspace(
+        VirtualWorkspace.SHARED,
+        install_driver=False,
+        config=SessionConfig(hide_mode="virtual_screen"),
+        timeout=60.0,
+    ) as space:
+        space.launch([CHARMAP], timeout=45.0)
+        device = space.monitor.device
+
+        class _Shot:
+            def __init__(self, image, rect):
+                self.image, self.rect = image, rect
+
+        with space.record_desktop(
+            tmp_path / "d.gif", fps=8, duration=0.5,
+            source=lambda: _Shot(Image.new("RGB", (32, 24)), (0, 0, 32, 24)),
+        ) as rec:
+            time.sleep(0.8)
+        report = rec.report()
+
+    assert report.target == f"desktop:{device}"
+    assert tuple(report.size) == (32, 24)
+
+
 # -- desktop recording (needs a working screen DC) -------------------------------------