dxcam 0.2.0.dev1__tar.gz → 0.3.0.dev1__tar.gz

{dxcam-0.2.0.dev1/dxcam.egg-info → dxcam-0.3.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dxcam
-Version: 0.2.0.dev1
+Version: 0.3.0.dev1
 Summary: A Python high-performance screenshot library for Windows using Desktop Duplication API
 Author: ra1nty
 License-Expression: MIT
@@ -49,19 +49,22 @@ Dynamic: license-file
 ```python
 import dxcam
 
-camera = dxcam.create()
-frame = camera.grab()
+with dxcam.create() as camera:
+    frame = camera.grab()
 ```
 
+> **Live API Docs:** [https://ra1nty.github.io/DXcam/](https://ra1nty.github.io/DXcam/)
+
 ## Introduction
 DXcam is a high-performance python screenshot and capture library for Windows based on the Desktop Duplication API.
 It is designed for low-latency, high-FPS capture pipelines (including full-screen Direct3D applications).
 
 Compared with common Python alternatives, DXcam focuses on:
-- Higher capture throughput
+- Higher capture throughput (240+fps on 1080p)
 - Stable capture for full-screen exclusive Direct3D apps
-- Correct handling of scaled/stretched outputs
-- Better FPS pacing for continuous/video capture
+- Better FPS pacing for continuous video capture
+- Support DXGI / Windows Graphics Capture dual backend
+- Seamless integration for AI Agent / Computer Vision use cases.
 
 ## Installation
 ### From PyPI (pip)
@@ -79,39 +82,12 @@ Notes:
 - Official Windows wheels are built for CPython `3.10` to `3.14`.
 - Binary wheels include the Cython kernels used by processor backends.
 
-### From source (uv)
-```bash
-uv sync
-# include OpenCV conversion backend
-uv sync --extra cv2
-# include optional Cython tooling
-uv sync --extra cython
-# include WinRT backend
-uv sync --extra winrt
-```
-
-Build local Cython kernels from source:
-```bash
-set DXCAM_BUILD_CYTHON=1
-uv pip install -e .[cython] --no-build-isolation
-```
-
-### Dev environment (uv + ruff + ty)
-```bash
-uv venv --python 3.11 .venv
-uv sync --dev
-uv run ruff check dxcam
-uv run ty check dxcam
-```
-
-### API docs (pdoc)
-Generate autodocs for the public API surface:
-```bash
-uv run pdoc -d google -o site dxcam dxcam.dxcam dxcam.types
-```
+### From source
+Please refer to [CONTRIBUTING](CONTRIBUTING.md).
 
-Preview locally by opening `site/index.html`.
-CI builds docs on pull requests, and docs are deployed from `main` via GitHub Pages.
+### Contributing / Dev
+Contributions are welcome!
+Development setup and contributor workflow are documented in [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## Usage
 Each output (monitor) is associated with one `DXCamera` instance.
@@ -121,7 +97,7 @@ import dxcam
 camera = dxcam.create()  # primary output on device 0
 ```
 
-To specify backend:
+To specify backends:
 ```python
 camera = dxcam.create(
     backend="dxgi", # default Desktop Duplication backend
@@ -133,7 +109,7 @@ camera = dxcam.create(
 ```python
 frame = camera.grab()
 ```
-`grab()` returns a `numpy.ndarray`. `None` if no new frame is available since the last capture (for backward compatibility); use `new_frame_only=False` to reuse the latest cached one-shot frame.
+`grab()` returns a `numpy.ndarray`. `None` if no new frame is available since the last capture (for backward compatibility); use `camera.grab(new_frame_only=False)` to make dxcam always return the latest frame.
 
 Use `copy=False` (or `camera.grab_view()`) for a zero-copy view. This is faster, but the returned buffer can be overwritten by later captures.
 
@@ -167,6 +143,24 @@ Useful variants:
 
 > When `start()` capture is running, calling `grab()` reads from the in-memory ring buffer instead of directly polling DXGI.
 
+### Safely Releasing Resources
+`release()` stops capture, frees buffers, and releases capture resources.
+After `release()`, the same instance cannot be reused.
+
+```python
+camera = dxcam.create(output_idx=0, output_color="BGR")
+camera.release()
+# camera.start()  # raises RuntimeError
+```
+Equivalently you can use context manager:
+```python
+with dxcam.create() as camera:
+    frame = camera.grab()
+# resource released automatically
+```
+
+**Full API Docs:** [https://ra1nty.github.io/DXcam/](https://ra1nty.github.io/DXcam/)
+
 ## Advanced Usage and Remarks
 ### Multiple monitors / GPUs
 ```python
@@ -257,12 +251,13 @@ DXcam supports two capture backends:
 
 Use it like this:
 ```python
-camera = dxcam.create(backend="dxgi")   # default
+camera = dxcam.create(backend="dxgi")
 camera = dxcam.create(backend="winrt")
 ```
 
 Guideline:
-- Start with `dxgi` for most workloads.
+- If you need cursor rendering, use `winrt`.
+- Start with `dxgi` for most workloads, especially one-shot grab.
 - Try `winrt` if it performs better on your machine or fits your app constraints.
 
 ### Processor Backend
@@ -293,16 +288,6 @@ If `processor_backend="numpy"` is selected but compiled kernels are unavailable,
 DXcam logs a warning and falls back to `cv2` behavior. In that fallback path,
 install OpenCV for non-`BGRA` output modes.
 
-### Safely Releasing Resources
-`release()` stops capture, frees buffers, and releases capture resources.
-After `release()`, the same instance cannot be reused.
-
-```python
-camera = dxcam.create(output_idx=0, output_color="BGR")
-camera.release()
-# camera.start()  # raises RuntimeError
-```
-
 ## Benchmarks
 When using a similar logic (only capture newly rendered frames) running on a 240fps output, ```DXCam, python-mss, D3DShot``` benchmarked as follow:
 
@@ -319,16 +304,9 @@ The benchmark is across 5 runs, with a light-moderate usage on my PC (5900X + 30
 | 60fps         | 61.71, 0.26 :checkered_flag: | N/A     | 47.11, 1.33  |
 | 30fps         | 30.08, 0.02 :checkered_flag:  | N/A     | 21.24, 0.17  |
 
-Processor backend comparison helper:
-```bash
-python benchmarks/dxcam_processor_compare.py --backend dxgi --target-fps 120 --target-frames 1000
-python benchmarks/dxcam_capture.py --backend dxgi --processor-backend numpy
-python benchmarks/numpy_processor_micro.py --width 3840 --height 2160 --modes RGB --variants process into --processor-backends cv2 numpy
-```
-
 
 ## Work Referenced
 
 [OBS Studio](https://github.com/obsproject/obs-studio) - implementation ideas and references.
 
-[D3DShot](https://github.com/SerpentAI/D3DShot/) : DXcam borrows the ctypes header directly from the no-longer maintained D3DShot.
+[D3DShot](https://github.com/SerpentAI/D3DShot/) : DXcam borrowed some ctypes header from the no-longer maintained D3DShot.

{dxcam-0.2.0.dev1 → dxcam-0.3.0.dev1}/README.md

@@ -4,19 +4,22 @@
 ```python
 import dxcam
 
-camera = dxcam.create()
-frame = camera.grab()
+with dxcam.create() as camera:
+    frame = camera.grab()
 ```
 
+> **Live API Docs:** [https://ra1nty.github.io/DXcam/](https://ra1nty.github.io/DXcam/)
+
 ## Introduction
 DXcam is a high-performance python screenshot and capture library for Windows based on the Desktop Duplication API.
 It is designed for low-latency, high-FPS capture pipelines (including full-screen Direct3D applications).
 
 Compared with common Python alternatives, DXcam focuses on:
-- Higher capture throughput
+- Higher capture throughput (240+fps on 1080p)
 - Stable capture for full-screen exclusive Direct3D apps
-- Correct handling of scaled/stretched outputs
-- Better FPS pacing for continuous/video capture
+- Better FPS pacing for continuous video capture
+- Support DXGI / Windows Graphics Capture dual backend
+- Seamless integration for AI Agent / Computer Vision use cases.
 
 ## Installation
 ### From PyPI (pip)
@@ -34,39 +37,12 @@ Notes:
 - Official Windows wheels are built for CPython `3.10` to `3.14`.
 - Binary wheels include the Cython kernels used by processor backends.
 
-### From source (uv)
-```bash
-uv sync
-# include OpenCV conversion backend
-uv sync --extra cv2
-# include optional Cython tooling
-uv sync --extra cython
-# include WinRT backend
-uv sync --extra winrt
-```
-
-Build local Cython kernels from source:
-```bash
-set DXCAM_BUILD_CYTHON=1
-uv pip install -e .[cython] --no-build-isolation
-```
-
-### Dev environment (uv + ruff + ty)
-```bash
-uv venv --python 3.11 .venv
-uv sync --dev
-uv run ruff check dxcam
-uv run ty check dxcam
-```
-
-### API docs (pdoc)
-Generate autodocs for the public API surface:
-```bash
-uv run pdoc -d google -o site dxcam dxcam.dxcam dxcam.types
-```
+### From source
+Please refer to [CONTRIBUTING](CONTRIBUTING.md).
 
-Preview locally by opening `site/index.html`.
-CI builds docs on pull requests, and docs are deployed from `main` via GitHub Pages.
+### Contributing / Dev
+Contributions are welcome!
+Development setup and contributor workflow are documented in [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## Usage
 Each output (monitor) is associated with one `DXCamera` instance.
@@ -76,7 +52,7 @@ import dxcam
 camera = dxcam.create()  # primary output on device 0
 ```
 
-To specify backend:
+To specify backends:
 ```python
 camera = dxcam.create(
     backend="dxgi", # default Desktop Duplication backend
@@ -88,7 +64,7 @@ camera = dxcam.create(
 ```python
 frame = camera.grab()
 ```
-`grab()` returns a `numpy.ndarray`. `None` if no new frame is available since the last capture (for backward compatibility); use `new_frame_only=False` to reuse the latest cached one-shot frame.
+`grab()` returns a `numpy.ndarray`. `None` if no new frame is available since the last capture (for backward compatibility); use `camera.grab(new_frame_only=False)` to make dxcam always return the latest frame.
 
 Use `copy=False` (or `camera.grab_view()`) for a zero-copy view. This is faster, but the returned buffer can be overwritten by later captures.
 
@@ -122,6 +98,24 @@ Useful variants:
 
 > When `start()` capture is running, calling `grab()` reads from the in-memory ring buffer instead of directly polling DXGI.
 
+### Safely Releasing Resources
+`release()` stops capture, frees buffers, and releases capture resources.
+After `release()`, the same instance cannot be reused.
+
+```python
+camera = dxcam.create(output_idx=0, output_color="BGR")
+camera.release()
+# camera.start()  # raises RuntimeError
+```
+Equivalently you can use context manager:
+```python
+with dxcam.create() as camera:
+    frame = camera.grab()
+# resource released automatically
+```
+
+**Full API Docs:** [https://ra1nty.github.io/DXcam/](https://ra1nty.github.io/DXcam/)
+
 ## Advanced Usage and Remarks
 ### Multiple monitors / GPUs
 ```python
@@ -212,12 +206,13 @@ DXcam supports two capture backends:
 
 Use it like this:
 ```python
-camera = dxcam.create(backend="dxgi")   # default
+camera = dxcam.create(backend="dxgi")
 camera = dxcam.create(backend="winrt")
 ```
 
 Guideline:
-- Start with `dxgi` for most workloads.
+- If you need cursor rendering, use `winrt`.
+- Start with `dxgi` for most workloads, especially one-shot grab.
 - Try `winrt` if it performs better on your machine or fits your app constraints.
 
 ### Processor Backend
@@ -248,16 +243,6 @@ If `processor_backend="numpy"` is selected but compiled kernels are unavailable,
 DXcam logs a warning and falls back to `cv2` behavior. In that fallback path,
 install OpenCV for non-`BGRA` output modes.
 
-### Safely Releasing Resources
-`release()` stops capture, frees buffers, and releases capture resources.
-After `release()`, the same instance cannot be reused.
-
-```python
-camera = dxcam.create(output_idx=0, output_color="BGR")
-camera.release()
-# camera.start()  # raises RuntimeError
-```
-
 ## Benchmarks
 When using a similar logic (only capture newly rendered frames) running on a 240fps output, ```DXCam, python-mss, D3DShot``` benchmarked as follow:
 
@@ -274,16 +259,9 @@ The benchmark is across 5 runs, with a light-moderate usage on my PC (5900X + 30
 | 60fps         | 61.71, 0.26 :checkered_flag: | N/A     | 47.11, 1.33  |
 | 30fps         | 30.08, 0.02 :checkered_flag:  | N/A     | 21.24, 0.17  |
 
-Processor backend comparison helper:
-```bash
-python benchmarks/dxcam_processor_compare.py --backend dxgi --target-fps 120 --target-frames 1000
-python benchmarks/dxcam_capture.py --backend dxgi --processor-backend numpy
-python benchmarks/numpy_processor_micro.py --width 3840 --height 2160 --modes RGB --variants process into --processor-backends cv2 numpy
-```
-
 
 ## Work Referenced
 
 [OBS Studio](https://github.com/obsproject/obs-studio) - implementation ideas and references.
 
-[D3DShot](https://github.com/SerpentAI/D3DShot/) : DXcam borrows the ctypes header directly from the no-longer maintained D3DShot.
+[D3DShot](https://github.com/SerpentAI/D3DShot/) : DXcam borrowed some ctypes header from the no-longer maintained D3DShot.

{dxcam-0.2.0.dev1 → dxcam-0.3.0.dev1}/dxcam/__init__.py

@@ -82,9 +82,9 @@ class Singleton(type):
 class DXFactory(metaclass=Singleton):
     """Factory that owns device/output discovery and camera singletons."""
 
-    _camera_instances: weakref.WeakValueDictionary[tuple[int, int, CaptureBackend], DXCamera] = (
-        weakref.WeakValueDictionary()
-    )
+    _camera_instances: weakref.WeakValueDictionary[
+        tuple[int, int, CaptureBackend], DXCamera
+    ] = weakref.WeakValueDictionary()
 
     def __init__(self) -> None:
         p_adapters = enum_dxgi_adapters()
@@ -104,7 +104,7 @@ class DXFactory(metaclass=Singleton):
         output_idx: int | None = None,
         region: Region | None = None,
         output_color: ColorMode = "RGB",
-        max_buffer_len: int = 64,
+        max_buffer_len: int = 8,
         backend: CaptureBackend = "dxgi",
         processor_backend: ProcessorBackend = "cv2",
     ) -> DXCamera:
@@ -122,7 +122,9 @@ class DXFactory(metaclass=Singleton):
                 if metadata and metadata[1]
             ]
             if not primary_output_indices:
-                raise RuntimeError(f"No primary output found for device index {device_idx}")
+                raise RuntimeError(
+                    f"No primary output found for device index {device_idx}"
+                )
             output_idx = primary_output_indices[0]
         instance_key = (device_idx, output_idx, backend)
         existing_camera = self._camera_instances.get(instance_key)
@@ -225,7 +227,7 @@ def create(
     output_idx: int | None = None,
     region: Region | None = None,
     output_color: ColorMode = "RGB",
-    max_buffer_len: int = 64,
+    max_buffer_len: int = 8,
     backend: CaptureBackend = "dxgi",
     processor_backend: ProcessorBackend = "cv2",
 ) -> DXCamera:

{dxcam-0.2.0.dev1 → dxcam-0.3.0.dev1}/dxcam/_libs/dxgi.py

@@ -5,8 +5,10 @@ from .d3d11 import ID3D11Device
 
 
 DXGI_ERROR_ACCESS_LOST = 0x887A0026
+DXGI_ERROR_DEVICE_REMOVED = 0x887A0005
 DXGI_ERROR_NOT_FOUND = 0x887A0002
 DXGI_ERROR_SESSION_DISCONNECTED = 0x887A0028
+DXGI_ERROR_UNSUPPORTED = 0x887A0004
 DXGI_ERROR_WAIT_TIMEOUT = 0x887A0027
 
 DXGI_OUTDUPL_FLAG_NONE = 0x0

{dxcam-0.2.0.dev1 → dxcam-0.3.0.dev1}/dxcam/core/backend.py

@@ -29,6 +29,17 @@ _BACKEND_CREATORS: dict[
 
 
 def normalize_backend_name(backend: str) -> CaptureBackend:
+    """Normalize and validate a capture backend name.
+
+    Args:
+        backend: Backend name provided by user input.
+
+    Returns:
+        Lower-cased validated backend literal (``"dxgi"`` or ``"winrt"``).
+
+    Raises:
+        ValueError: If ``backend`` is not a supported capture backend.
+    """
     normalized = backend.lower()
     if normalized not in _SUPPORTED_BACKENDS:
         supported = ", ".join(_SUPPORTED_BACKENDS)
@@ -42,6 +53,19 @@ def create_backend_duplicator(
     output: Output,
     device: Device,
 ) -> Any:
+    """Create a backend-specific duplicator instance.
+
+    Args:
+        backend: Selected capture backend.
+        output: Output descriptor to capture from.
+        device: Device descriptor associated with ``output``.
+
+    Returns:
+        A duplicator instance that implements the capture backend contract.
+
+    Raises:
+        ValueError: If ``backend`` has no registered factory.
+    """
     creator = _BACKEND_CREATORS.get(backend)
     if creator is None:
         # Defensive fallback in case literals are expanded without wiring.

dxcam-0.3.0.dev1/dxcam/core/capture_loop.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from _thread import LockType
+from threading import Event
+from typing import Callable
+
+import numpy as np
+
+from dxcam.core.capture_runtime import CaptureRuntime
+from dxcam.types import Frame, Region
+
+GrabIntoFn = Callable[[Region, Frame], tuple[bool, int, int, int]]
+ProcessStagingFrameFn = Callable[[int, int], Frame]
+HandleFrameSizeChangeFn = Callable[[int, int], None]
+
+
+class CaptureLoopRunner:
+    """Runs one capture-loop iteration and updates the ring buffer."""
+
+    def __init__(
+        self,
+        *,
+        lock: LockType,
+        frame_available_event: Event,
+        runtime: CaptureRuntime,
+        grab_into: GrabIntoFn,
+        process_staging_frame: ProcessStagingFrameFn,
+        handle_frame_size_change: HandleFrameSizeChangeFn,
+    ) -> None:
+        self._lock = lock
+        self._frame_available_event = frame_available_event
+        self._runtime = runtime
+        self._grab_into = grab_into
+        self._process_staging_frame = process_staging_frame
+        self._handle_frame_size_change = handle_frame_size_change
+
+    def run_once(self, *, region: Region, video_mode: bool) -> None:
+        with self._lock:
+            write_slot = self._runtime.reserve_write_slot()
+            if write_slot is None:
+                return
+            write_idx, write_dst = write_slot
+
+        captured, frame_ticks, frame_width, frame_height = self._grab_into(
+            region,
+            write_dst,
+        )
+        if captured:
+            with self._lock:
+                if self._runtime.commit_write(write_idx, frame_ticks):
+                    self._frame_available_event.set()
+            return
+
+        if frame_width > 0 and frame_height > 0:
+            frame = self._process_staging_frame(frame_width, frame_height)
+            with self._lock:
+                current_shape = self._runtime.current_frame_shape()
+                if current_shape is None:
+                    return
+                current_height, current_width = current_shape
+                if frame.shape[0] != current_height or frame.shape[1] != current_width:
+                    self._handle_frame_size_change(frame.shape[0], frame.shape[1])
+
+                write_slot = self._runtime.reserve_write_slot()
+                if write_slot is None:
+                    return
+                write_idx, write_dst = write_slot
+
+            np.copyto(write_dst, frame)
+            with self._lock:
+                if self._runtime.commit_write(write_idx, frame_ticks):
+                    self._frame_available_event.set()
+            return
+
+        if video_mode:
+            with self._lock:
+                duplicate_copy = self._runtime.reserve_duplicate_copy()
+            if duplicate_copy is None:
+                return
+            write_idx, write_dst, previous_dst, frame_ticks = duplicate_copy
+            np.copyto(write_dst, previous_dst)
+            with self._lock:
+                if self._runtime.commit_write(write_idx, frame_ticks):
+                    self._frame_available_event.set()
+        return

dxcam-0.3.0.dev1/dxcam/core/capture_runtime.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+from numpy.typing import NDArray
+
+from dxcam.types import Frame
+
+
+@dataclass
+class CaptureRuntime:
+    """Ring-buffer runtime state for threaded capture.
+
+    In threaded mode, producer flow is:
+    1) reserve slot under lock
+    2) copy frame data outside lock
+    3) commit metadata under lock
+
+    Callers must ensure frame-buffer clear/realloc never runs concurrently from
+    a non-producer thread while producer is active.
+    """
+
+    max_buffer_len: int
+    channel_size: int
+    frame_buffer: Frame | None = None
+    frame_time_ticks: NDArray[np.int64] | None = None
+    head: int = 0
+    tail: int = 0
+    full: bool = False
+    has_frame: bool = False
+    frame_count: int = 0
+    latest_frame_ticks: int | None = None
+
+    def allocate_for_shape(self, frame_height: int, frame_width: int) -> None:
+        frame_shape = (frame_height, frame_width, self.channel_size)
+        self.frame_buffer = np.empty(
+            (self.max_buffer_len, *frame_shape),
+            dtype=np.uint8,
+        )
+        self.frame_time_ticks = np.zeros(self.max_buffer_len, dtype=np.int64)
+        self.head = 0
+        self.tail = 0
+        self.full = False
+        self.has_frame = False
+        self.frame_count = 0
+        self.latest_frame_ticks = None
+
+    def clear(self) -> None:
+        self.frame_buffer = None
+        self.frame_time_ticks = None
+        self.head = 0
+        self.tail = 0
+        self.full = False
+        self.has_frame = False
+        self.frame_count = 0
+        self.latest_frame_ticks = None
+
+    def current_frame_shape(self) -> tuple[int, int] | None:
+        if self.frame_buffer is None:
+            return None
+        return self.frame_buffer.shape[1], self.frame_buffer.shape[2]
+
+    def reserve_write_slot(self) -> tuple[int, Frame] | None:
+        if self.frame_buffer is None:
+            return None
+        write_idx = self.head
+        return write_idx, self.frame_buffer[write_idx]
+
+    def reserve_duplicate_copy(
+        self,
+    ) -> tuple[int, Frame, Frame, int] | None:
+        if (
+            self.frame_buffer is None
+            or self.frame_time_ticks is None
+            or not self.has_frame
+        ):
+            return None
+        write_idx = self.head
+        previous_idx = (self.head - 1) % self.max_buffer_len
+        dst = self.frame_buffer[write_idx]
+        src = self.frame_buffer[previous_idx]
+        frame_ticks = int(self.frame_time_ticks[previous_idx])
+        return write_idx, dst, src, frame_ticks
+
+    def commit_write(self, write_idx: int, frame_ticks: int) -> bool:
+        if self.frame_buffer is None or self.frame_time_ticks is None:
+            return False
+        if write_idx != self.head:
+            return False
+        if self.full:
+            self.tail = (self.tail + 1) % self.max_buffer_len
+        self.frame_time_ticks[write_idx] = frame_ticks
+        self.head = (write_idx + 1) % self.max_buffer_len
+        self.latest_frame_ticks = frame_ticks
+        self.frame_count += 1
+        self.full = self.head == self.tail
+        self.has_frame = True
+        return True
+
+    def peek_latest(self, copy: bool = True) -> Frame | None:
+        if self.frame_buffer is None or not self.has_frame:
+            return None
+        latest_idx = (self.head - 1) % self.max_buffer_len
+        frame = self.frame_buffer[latest_idx]
+        return np.array(frame, copy=True) if copy else frame
+
+    def peek_latest_with_ticks(
+        self,
+        copy: bool = True,
+    ) -> tuple[Frame, int] | None:
+        if (
+            self.frame_buffer is None
+            or self.frame_time_ticks is None
+            or not self.has_frame
+        ):
+            return None
+        latest_idx = (self.head - 1) % self.max_buffer_len
+        frame = self.frame_buffer[latest_idx]
+        frame_ticks = int(self.frame_time_ticks[latest_idx])
+        if copy:
+            return np.array(frame, copy=True), frame_ticks
+        return frame, frame_ticks

{dxcam-0.2.0.dev1 → dxcam-0.3.0.dev1}/dxcam/core/device.py

@@ -14,9 +14,13 @@ from dxcam._libs.d3d11 import (
 )
 from dxcam._libs.dxgi import (
     DXGI_ADAPTER_DESC1,
-    DXGI_ERROR_NOT_FOUND,
     IDXGIOutput1,
 )
+from dxcam.core.dxgi_errors import (
+    DXGITransientContext,
+    com_error_hresult_u32,
+    is_transient_hresult,
+)
 
 
 @dataclass
@@ -70,7 +74,11 @@ class Device:
                 p_outputs.append(p_output)
                 i += 1
             except comtypes.COMError as ce:
-                if ctypes.c_int32(DXGI_ERROR_NOT_FOUND).value == ce.args[0]:
+                hresult_u32 = com_error_hresult_u32(ce)
+                if is_transient_hresult(
+                    hresult_u32,
+                    DXGITransientContext.ENUM_OUTPUTS,
+                ):
                     break
                 raise
         return p_outputs