dxcam 0.4.0.dev1__tar.gz → 0.4.0.dev2__tar.gz

{dxcam-0.4.0.dev1/dxcam.egg-info → dxcam-0.4.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dxcam
-Version: 0.4.0.dev1
+Version: 0.4.0.dev2
 Summary: A Python high-performance screenshot library for Windows using Desktop Duplication API
 Author: ra1nty
 License-Expression: MIT
@@ -105,13 +105,15 @@ camera = dxcam.create(
 )
 ```
 Note:
-- From 0.4.0 the `dxcam.create(max_buffer_len=...)` is deprecated, screen capture now always uses a tripple buffer.
+- Version 0.4 uses a fixed three-slot frame buffer; `max_buffer_len` has been removed.
+- Device discovery happens on the first `create()`, `device_info()`, or `output_info()` call.
+- Upgrading from 0.3? See the [0.4 migration guide](https://github.com/ra1nty/DXcam/blob/dev/docs/migration-0.4.md).
 
 ### Screenshot
 ```python
 frame = camera.grab()
 ```
-`grab()` returns a `numpy.ndarray`. `None` if no new frame is available since the last capture; use `camera.grab(new_frame_only=False)` to make dxcam always return the latest frame.
+`grab()` returns a `numpy.ndarray`. In one-shot mode it returns `None` if no new frame is available; `camera.grab(new_frame_only=False)` can reuse the last cached frame. During threaded capture, it reads the latest published frame and ignores `new_frame_only`.
 
 Use `camera.grab_into(dst)` to reuse caller-managed memory.
 
@@ -134,9 +136,9 @@ camera.is_capturing  # False
 #### Consume the Screen Capture Data
 ```python
 for _ in range(1000):
-    frame = camera.get_latest_frame()  # blocks until a frame is available
+    frame = camera.get_latest_frame()  # waits for the first available frame
 ```
->The screen capture mode spins up a thread that polls newly rendered frames and publishes them into a latest-only in-memory frame buffer. The blocking and `video_mode` behavior is designed for downstream video recording and machine learning workloads.
+The capture thread publishes into a latest-only frame buffer. Once a frame is available, reads return immediately and can return the same timestamp repeatedly. Consumers control their own pacing; compare timestamps when you need only fresh frames. `target_fps` controls the producer, not the frequency of consumer reads.
 
 Useful variants:
 - `camera.get_latest_frame(with_timestamp=True)` -> `(frame, frame_timestamp)` -> return frame timestamp
@@ -147,6 +149,7 @@ Useful variants:
 ### Safely Releasing Resources
 `release()` stops capture, frees buffers, and releases capture resources.
 After `release()`, the same instance cannot be reused.
+In-flight readers retain their staging surfaces until readout completes, including across stop or output recovery.
 
 ```python
 camera = dxcam.create(output_idx=0, output_color="BGR")
@@ -197,10 +200,10 @@ Notes:
 - `RGB`, `BGR`, `RGBA`, `GRAY` require conversion (`cv2`, `cython`, or compiled `numpy` backend).
 
 ### Frame Buffer
-DXcam uses a fixed three-slot latest-only frame buffer in-memory. Readers always consume the newest published frame, and older staged frames may be overwritten once they are no longer leased.
+DXcam uses a fixed three-slot latest-only frame buffer in-memory. Readers consume the newest published frame. A surface being read is never overwritten; if no safe write slot is available, capture skips that cycle. Older surfaces are released only after their readers finish.
 
 ```python
-camera = dxcam.create()  # max_buffer_len is accepted but ignored
+camera = dxcam.create()
 ```
 
 ### Target FPS
@@ -230,21 +233,32 @@ With `video_mode=True`, DXcam continues publishing at target FPS, reusing the pr
 ```python
 import cv2
 import dxcam
+import time
 
 target_fps = 30
 camera = dxcam.create(output_color="BGR")
 camera.start(target_fps=target_fps, video_mode=True)
 
 writer = cv2.VideoWriter(
-    "video.mp4", cv2.VideoWriter_fourcc(*"mp4v"), target_fps, (1920, 1080)
+    "video.mp4", cv2.VideoWriter_fourcc(*"mp4v"), target_fps,
+    (camera.width, camera.height),
 )
-for _ in range(600):
-    writer.write(camera.get_latest_frame())
-
-camera.stop()
-writer.release()
+try:
+    next_frame = time.perf_counter()
+    for _ in range(600):
+        time.sleep(max(0, next_frame - time.perf_counter()))
+        next_frame = time.perf_counter() + 1 / target_fps
+        frame = camera.get_latest_frame()
+        if frame is not None:
+            writer.write(frame)
+finally:
+    camera.release()
+    writer.release()
 ```
 
+Latest-frame reads return immediately once a frame exists. Pace the consumer as
+above to avoid filling the video with repeated reads as fast as Python can run.
+
 ### Capture Backend
 DXcam supports two capture backends:
 - `dxgi` (default): Desktop Duplication API path with broad compatibility.
@@ -294,6 +308,9 @@ DXcam raises a runtime error because that backend is explicitly the direct
 Cython path.
 
 ## Benchmarks
+See the [0.4 development comparison against PyPI 0.3.0](https://github.com/ra1nty/DXcam/blob/dev/benchmarks/capture_comparison.md)
+for measured fresh-frame throughput, frame age, CPU use, and reproducible steps.
+
 When using a similar logic (only capture newly rendered frames) running on a 240fps output, ```DXCam, python-mss, D3DShot``` benchmarked as follow:
 
 |             | DXcam  | python-mss | D3DShot |

{dxcam-0.4.0.dev1 → dxcam-0.4.0.dev2}/README.md

@@ -60,13 +60,15 @@ camera = dxcam.create(
 )
 ```
 Note:
-- From 0.4.0 the `dxcam.create(max_buffer_len=...)` is deprecated, screen capture now always uses a tripple buffer.
+- Version 0.4 uses a fixed three-slot frame buffer; `max_buffer_len` has been removed.
+- Device discovery happens on the first `create()`, `device_info()`, or `output_info()` call.
+- Upgrading from 0.3? See the [0.4 migration guide](https://github.com/ra1nty/DXcam/blob/dev/docs/migration-0.4.md).
 
 ### Screenshot
 ```python
 frame = camera.grab()
 ```
-`grab()` returns a `numpy.ndarray`. `None` if no new frame is available since the last capture; use `camera.grab(new_frame_only=False)` to make dxcam always return the latest frame.
+`grab()` returns a `numpy.ndarray`. In one-shot mode it returns `None` if no new frame is available; `camera.grab(new_frame_only=False)` can reuse the last cached frame. During threaded capture, it reads the latest published frame and ignores `new_frame_only`.
 
 Use `camera.grab_into(dst)` to reuse caller-managed memory.
 
@@ -89,9 +91,9 @@ camera.is_capturing  # False
 #### Consume the Screen Capture Data
 ```python
 for _ in range(1000):
-    frame = camera.get_latest_frame()  # blocks until a frame is available
+    frame = camera.get_latest_frame()  # waits for the first available frame
 ```
->The screen capture mode spins up a thread that polls newly rendered frames and publishes them into a latest-only in-memory frame buffer. The blocking and `video_mode` behavior is designed for downstream video recording and machine learning workloads.
+The capture thread publishes into a latest-only frame buffer. Once a frame is available, reads return immediately and can return the same timestamp repeatedly. Consumers control their own pacing; compare timestamps when you need only fresh frames. `target_fps` controls the producer, not the frequency of consumer reads.
 
 Useful variants:
 - `camera.get_latest_frame(with_timestamp=True)` -> `(frame, frame_timestamp)` -> return frame timestamp
@@ -102,6 +104,7 @@ Useful variants:
 ### Safely Releasing Resources
 `release()` stops capture, frees buffers, and releases capture resources.
 After `release()`, the same instance cannot be reused.
+In-flight readers retain their staging surfaces until readout completes, including across stop or output recovery.
 
 ```python
 camera = dxcam.create(output_idx=0, output_color="BGR")
@@ -152,10 +155,10 @@ Notes:
 - `RGB`, `BGR`, `RGBA`, `GRAY` require conversion (`cv2`, `cython`, or compiled `numpy` backend).
 
 ### Frame Buffer
-DXcam uses a fixed three-slot latest-only frame buffer in-memory. Readers always consume the newest published frame, and older staged frames may be overwritten once they are no longer leased.
+DXcam uses a fixed three-slot latest-only frame buffer in-memory. Readers consume the newest published frame. A surface being read is never overwritten; if no safe write slot is available, capture skips that cycle. Older surfaces are released only after their readers finish.
 
 ```python
-camera = dxcam.create()  # max_buffer_len is accepted but ignored
+camera = dxcam.create()
 ```
 
 ### Target FPS
@@ -185,21 +188,32 @@ With `video_mode=True`, DXcam continues publishing at target FPS, reusing the pr
 ```python
 import cv2
 import dxcam
+import time
 
 target_fps = 30
 camera = dxcam.create(output_color="BGR")
 camera.start(target_fps=target_fps, video_mode=True)
 
 writer = cv2.VideoWriter(
-    "video.mp4", cv2.VideoWriter_fourcc(*"mp4v"), target_fps, (1920, 1080)
+    "video.mp4", cv2.VideoWriter_fourcc(*"mp4v"), target_fps,
+    (camera.width, camera.height),
 )
-for _ in range(600):
-    writer.write(camera.get_latest_frame())
-
-camera.stop()
-writer.release()
+try:
+    next_frame = time.perf_counter()
+    for _ in range(600):
+        time.sleep(max(0, next_frame - time.perf_counter()))
+        next_frame = time.perf_counter() + 1 / target_fps
+        frame = camera.get_latest_frame()
+        if frame is not None:
+            writer.write(frame)
+finally:
+    camera.release()
+    writer.release()
 ```
 
+Latest-frame reads return immediately once a frame exists. Pace the consumer as
+above to avoid filling the video with repeated reads as fast as Python can run.
+
 ### Capture Backend
 DXcam supports two capture backends:
 - `dxgi` (default): Desktop Duplication API path with broad compatibility.
@@ -249,6 +263,9 @@ DXcam raises a runtime error because that backend is explicitly the direct
 Cython path.
 
 ## Benchmarks
+See the [0.4 development comparison against PyPI 0.3.0](https://github.com/ra1nty/DXcam/blob/dev/benchmarks/capture_comparison.md)
+for measured fresh-frame throughput, frame age, CPU use, and reproducible steps.
+
 When using a similar logic (only capture newly rendered frames) running on a 240fps output, ```DXCam, python-mss, D3DShot``` benchmarked as follow:
 
 |             | DXcam  | python-mss | D3DShot |

{dxcam-0.4.0.dev1 → dxcam-0.4.0.dev2}/dxcam/__init__.py

@@ -22,6 +22,7 @@ import signal
 import time
 import weakref
 from types import FrameType
+from threading import Lock, RLock
 from typing import Any, Callable, cast
 
 from dxcam.runtime.backend import normalize_backend_name
@@ -50,43 +51,22 @@ __all__ = [
 
 # Hide internal factory/signal plumbing from pdoc output.
 __pdoc__: dict[str, bool] = {
-    "Singleton": False,
     "DXFactory": False,
-    "_configure_comtypes_logging": False,
+    "_get_factory": False,
     "_handle_sigterm": False,
     "_install_sigterm_handler": False,
     "__factory": False,
 }
 
 
-def _configure_comtypes_logging() -> None:
-    # Suppress noisy per-frame COM Release debug logs from comtypes internals.
-    logging.getLogger("comtypes").setLevel(logging.INFO)
-    logging.getLogger("comtypes._post_coinit.unknwn").setLevel(logging.INFO)
-
-
-class Singleton(type):
-    """Metaclass that allows exactly one instance per class."""
-
-    _instances = {}
-
-    def __call__(cls, *args: Any, **kwargs: Any) -> Any:
-        if cls not in cls._instances:
-            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
-        else:
-            logger.warning("Only 1 instance of %s is allowed.", cls.__name__)
-
-        return cls._instances[cls]
-
-
-class DXFactory(metaclass=Singleton):
+class DXFactory:
     """Factory that owns device/output discovery and camera singletons."""
 
-    _camera_instances: weakref.WeakValueDictionary[
-        tuple[int, int, CaptureBackend], DXCamera
-    ] = weakref.WeakValueDictionary()
-
     def __init__(self) -> None:
+        self._camera_instances: weakref.WeakValueDictionary[
+            tuple[int, int, CaptureBackend], DXCamera
+        ] = weakref.WeakValueDictionary()
+        self._camera_lock = RLock()
         p_adapters = enum_dxgi_adapters()
         self.devices: list[Device] = []
         self.outputs: list[list[Output]] = []
@@ -104,7 +84,7 @@ class DXFactory(metaclass=Singleton):
         output_idx: int | None = None,
         region: Region | None = None,
         output_color: ColorMode = "RGB",
-        max_buffer_len: int = 8,
+        *,
         backend: CaptureBackend = "dxgi",
         processor_backend: ProcessorBackend = "cv2",
     ) -> DXCamera:
@@ -127,41 +107,32 @@ class DXFactory(metaclass=Singleton):
                 )
             output_idx = primary_output_indices[0]
         instance_key = (device_idx, output_idx, backend)
-        existing_camera = self._camera_instances.get(instance_key)
-        if existing_camera is not None and existing_camera.is_released:
-            logger.info(
-                "Dropping released DXCamera instance for device=%s output=%s backend=%s.",
-                device_idx,
-                output_idx,
-                backend,
-            )
-            del self._camera_instances[instance_key]
-            existing_camera = None
-        if existing_camera is not None:
-            logger.warning(
-                "DXCamera instance already exists for device=%s output=%s backend=%s; "
-                "returning the existing instance. Call release() before "
-                "recreating it with new parameters.",
-                device_idx,
-                output_idx,
-                backend,
+        with self._camera_lock:
+            existing_camera = self._camera_instances.get(instance_key)
+            if existing_camera is not None and not existing_camera.is_released:
+                logger.warning(
+                    "DXCamera instance already exists for device=%s output=%s "
+                    "backend=%s; returning the existing instance. Call release() "
+                    "before recreating it with new parameters.",
+                    device_idx,
+                    output_idx,
+                    backend,
+                )
+                return existing_camera
+
+            output = self.outputs[device_idx][output_idx]
+            output.update_desc()
+            camera = DXCamera(
+                output=output,
+                device=device,
+                region=region,
+                output_color=output_color,
+                backend=backend,
+                processor_backend=processor_backend,
             )
-            return existing_camera
-
-        output = self.outputs[device_idx][output_idx]
-        output.update_desc()
-        camera = DXCamera(
-            output=output,
-            device=device,
-            region=region,
-            output_color=output_color,
-            max_buffer_len=max_buffer_len,
-            backend=backend,
-            processor_backend=processor_backend,
-        )
-        self._camera_instances[instance_key] = camera
-        time.sleep(0.1)  # Fix for https://github.com/ra1nty/DXcam/issues/31
-        return camera
+            self._camera_instances[instance_key] = camera
+            time.sleep(0.1)  # Fix for https://github.com/ra1nty/DXcam/issues/31
+            return camera
 
     def device_info(self) -> str:
         ret = ""
@@ -181,18 +152,30 @@ class DXFactory(metaclass=Singleton):
         return ret
 
     def clean_up(self) -> None:
-        for _, camera in list(self._camera_instances.items()):
+        with self._camera_lock:
+            cameras = list(self._camera_instances.values())
+        for camera in cameras:
             camera.release()
 
 
-__factory = DXFactory()
-_configure_comtypes_logging()
+__factory: DXFactory | None = None
+_factory_lock = Lock()
+
+
+def _get_factory() -> DXFactory:
+    global __factory
+
+    with _factory_lock:
+        if __factory is None:
+            __factory = DXFactory()
+        return __factory
 
 
 def _handle_sigterm(signum: int, frame: FrameType | None) -> None:
     logger.info("Received SIGTERM; releasing active DXCamera instances.")
     try:
-        __factory.clean_up()
+        if __factory is not None:
+            __factory.clean_up()
     except Exception:
         logger.exception("Failed during DXCamera SIGTERM cleanup.")
 
@@ -213,8 +196,9 @@ def _install_sigterm_handler() -> None:
     if _sigterm_handler_installed:
         return
     try:
-        _previous_sigterm_handler = signal.getsignal(signal.SIGTERM)
+        previous = signal.getsignal(signal.SIGTERM)
         signal.signal(signal.SIGTERM, _handle_sigterm)
+        _previous_sigterm_handler = previous
         _sigterm_handler_installed = True
     except (ValueError, AttributeError):
         # ValueError: called outside the main thread.
@@ -227,7 +211,7 @@ def create(
     output_idx: int | None = None,
     region: Region | None = None,
     output_color: ColorMode = "RGB",
-    max_buffer_len: int = 8,
+    *,
     backend: CaptureBackend = "dxgi",
     processor_backend: ProcessorBackend = "cv2",
 ) -> DXCamera:
@@ -239,8 +223,6 @@ def create(
             the primary output.
         region: Optional capture region as ``(left, top, right, bottom)``.
         output_color: Output pixel format.
-        max_buffer_len: Kept for API compatibility. Threaded capture uses a
-            fixed three-slot latest-only frame buffer.
         backend: Capture backend, ``"dxgi"`` or ``"winrt"``.
         processor_backend: Post-processing backend, ``"cv2"`` (default),
             ``"cython"``, or ``"numpy"``. The ``"cython"`` backend uses the
@@ -262,12 +244,11 @@ def create(
         >>> cam.release()
     """
     _install_sigterm_handler()
-    return __factory.create(
+    return _get_factory().create(
         device_idx=device_idx,
         output_idx=output_idx,
         region=region,
         output_color=output_color,
-        max_buffer_len=max_buffer_len,
         backend=backend,
         processor_backend=processor_backend,
     )
@@ -280,7 +261,7 @@ def device_info() -> str:
         >>> import dxcam
         >>> print(dxcam.device_info())
     """
-    return __factory.device_info()
+    return _get_factory().device_info()
 
 
 def output_info() -> str:
@@ -290,4 +271,4 @@ def output_info() -> str:
         >>> import dxcam
         >>> print(dxcam.output_info())
     """
-    return __factory.output_info()
+    return _get_factory().output_info()

{dxcam-0.4.0.dev1 → dxcam-0.4.0.dev2}/dxcam/core/device.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import ctypes
-from dataclasses import dataclass
-from typing import Any, cast
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import Any, Iterator, cast
 
 import comtypes
 from dxcam._libs.d3d11 import (
@@ -11,6 +12,7 @@ from dxcam._libs.d3d11 import (
     D3D_FEATURE_LEVEL_11_0,
     ID3D11Device,
     ID3D11DeviceContext,
+    ID3D11Multithread,
 )
 from dxcam._libs.dxgi import (
     DXGI_ADAPTER_DESC1,
@@ -32,6 +34,7 @@ class Device:
     context: Any = None
     im_context: Any = None
     desc: DXGI_ADAPTER_DESC1 | None = None
+    _multithread: Any | None = field(default=None, init=False, repr=False)
 
     def __post_init__(self) -> None:
         self.desc = DXGI_ADAPTER_DESC1()
@@ -63,6 +66,32 @@ class Device:
         )
         device = cast(Any, self.device)
         device.GetImmediateContext(ctypes.byref(self.im_context))
+        try:
+            context = cast(Any, self.im_context)
+            multithread = context.QueryInterface(ID3D11Multithread)
+            multithread.SetMultithreadProtected(True)
+            if not multithread.GetMultithreadProtected():
+                raise RuntimeError("The device left multithread protection disabled.")
+        except Exception as exc:
+            raise RuntimeError(
+                "DXcam requires native Direct3D multithread protection "
+                "(ID3D11Multithread), but it could not be enabled."
+            ) from exc
+        self._multithread = multithread
+
+    @contextmanager
+    def context_guard(self) -> Iterator[None]:
+        """Serialize context/DXGI calls across every camera using this device."""
+        multithread = self._multithread
+        if multithread is None:
+            raise RuntimeError(
+                "Native Direct3D multithread protection is not initialized."
+            )
+        multithread.Enter()
+        try:
+            yield
+        finally:
+            multithread.Leave()
 
     def enum_outputs(self) -> list[Any]:
         i = 0

{dxcam-0.4.0.dev1 → dxcam-0.4.0.dev2}/dxcam/core/dxgi_duplicator.py

@@ -221,7 +221,7 @@ class DXGIDuplicator:
         So DXCam default to early release.
 
         Returns:
-            bool: Sucessfully
+            bool: Successfully
         """
         if self.duplicator is None or not self._frame_held:
             return True
@@ -263,7 +263,7 @@ class DXGIDuplicator:
             self.duplicator = None
 
     def __repr__(self) -> str:
-        return "<{} Initalized:{}>".format(
+        return "<{} Initialized:{}>".format(
             self.__class__.__name__,
             self.duplicator is not None,
         )

{dxcam-0.4.0.dev1 → dxcam-0.4.0.dev2}/dxcam/core/stagesurf.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 import ctypes
+from _thread import LockType
 from contextlib import contextmanager
 from dataclasses import InitVar, dataclass, field
+from threading import Lock
 from typing import Any, Iterator, cast
 
 from dxcam._libs.d3d11 import (
@@ -30,6 +32,7 @@ class StageSurface:
     texture: Any = None
     interface: Any = None
     _copy_region_box: D3D11_BOX = field(default_factory=D3D11_BOX, repr=False)
+    _map_lock: LockType = field(default_factory=Lock, init=False, repr=False)
     output: InitVar[Output | None] = None
     device: InitVar[Device | None] = None
     dim: InitVar[tuple[int, int] | None] = None
@@ -106,25 +109,30 @@ class StageSurface:
             self.rebuild(dim=dim)
 
     def map(self) -> DXGI_MAPPED_RECT:
-        if self.interface is None:
+        if self.interface is None or self._device is None:
             raise RuntimeError("StageSurface interface is not initialized.")
         rect: DXGI_MAPPED_RECT = DXGI_MAPPED_RECT()
-        self.interface.Map(ctypes.byref(rect), 1)
+        with self._device.context_guard():
+            self.interface.Map(ctypes.byref(rect), 1)
         return rect
 
     def unmap(self) -> None:
-        if self.interface is None:
+        if self.interface is None or self._device is None:
             raise RuntimeError("StageSurface interface is not initialized.")
-        self.interface.Unmap()
+        with self._device.context_guard():
+            self.interface.Unmap()
 
     @contextmanager
     def mapped(self) -> Iterator[DXGI_MAPPED_RECT]:
-        """Context-manager wrapper around map/unmap."""
-        rect = self.map()
-        try:
-            yield rect
-        finally:
-            self.unmap()
+        """Map/unmap under the device guard, without guarding CPU work."""
+        # Several readers can lease the latest frame, but DXGI permits only one
+        # active mapping of a surface. Leases keep it alive while readers queue.
+        with self._map_lock:
+            rect = self.map()
+            try:
+                yield rect
+            finally:
+                self.unmap()
 
     def copy_region_from(
         self,

{dxcam-0.4.0.dev1 → dxcam-0.4.0.dev2}/dxcam/core/winrt_duplicator.py

@@ -12,7 +12,7 @@ from typing import Any, Callable, Iterator, Literal, cast
 
 import comtypes
 
-from dxcam._libs.d3d11 import ID3D11Multithread, ID3D11Texture2D
+from dxcam._libs.d3d11 import ID3D11Texture2D
 from dxcam._libs.dxgi import IDXGIDevice, IDXGISurface
 from dxcam.core.com_ptr import clear_com_pointer
 from dxcam.core.device import Device
@@ -102,7 +102,6 @@ class WinRTDuplicator:
     _session: Any | None = field(default=None, init=False, repr=False)
     _capture_item: Any | None = field(default=None, init=False, repr=False)
     _winrt_device: Any | None = field(default=None, init=False, repr=False)
-    _multithread: Any | None = field(default=None, init=False, repr=False)
     _dxgi_surface: Any = field(
         default_factory=lambda: ctypes.POINTER(IDXGISurface)(), init=False, repr=False
     )
@@ -138,7 +137,6 @@ class WinRTDuplicator:
         )
         self._border_required = self._resolve_bool_env("DXCAM_WINRT_BORDER_REQUIRED")
         self._configure_qpc_frequency()
-        self._configure_multithread_protection(device=device)
         self._create_capture_session(output=output, device=device)
 
     def _resolve_frame_wait_seconds(self) -> float:
@@ -246,7 +244,9 @@ class WinRTDuplicator:
                     mode = self._dirty_region_mode_enum.REPORT_AND_RENDER
                 self._session.dirty_region_mode = mode
             except Exception:
-                logger.warning("Failed to set session dirty_region_mode.", exc_info=True)
+                logger.warning(
+                    "Failed to set session dirty_region_mode.", exc_info=True
+                )
         if self._cursor_capture_enabled is not None:
             try:
                 self._session.is_cursor_capture_enabled = self._cursor_capture_enabled
@@ -259,7 +259,9 @@ class WinRTDuplicator:
             try:
                 self._session.is_border_required = self._border_required
             except Exception:
-                logger.warning("Failed to set session is_border_required.", exc_info=True)
+                logger.warning(
+                    "Failed to set session is_border_required.", exc_info=True
+                )
 
     def _configure_qpc_frequency(self) -> None:
         freq = ctypes.c_longlong()
@@ -329,34 +331,6 @@ class WinRTDuplicator:
         if self._frame_arrived_event is not None:
             self._frame_arrived_event.set()
 
-    def _configure_multithread_protection(self, device: Device) -> None:
-        try:
-            self._multithread = device.im_context.QueryInterface(ID3D11Multithread)
-        except comtypes.COMError:
-            logger.debug("ID3D11Multithread not available for WinRT backend.")
-            self._multithread = None
-            return
-        try:
-            self._multithread.SetMultithreadProtected(True)
-        except Exception:
-            logger.debug("Failed to enable multithread protection.", exc_info=True)
-
-    def enter_multithread(self) -> None:
-        if self._multithread is None:
-            return
-        try:
-            self._multithread.Enter()
-        except Exception:
-            logger.debug("Failed to enter ID3D11Multithread lock.", exc_info=True)
-
-    def leave_multithread(self) -> None:
-        if self._multithread is None:
-            return
-        try:
-            self._multithread.Leave()
-        except Exception:
-            logger.debug("Failed to leave ID3D11Multithread lock.", exc_info=True)
-
     def _monitor_handle_to_int(self, hmonitor: Any) -> int:
         value = getattr(hmonitor, "value", hmonitor)
         monitor = int(value or 0)
@@ -372,7 +346,9 @@ class WinRTDuplicator:
             try:
                 close_fn()
             except Exception:
-                logger.debug("Ignoring exception while closing %s.", name, exc_info=True)
+                logger.debug(
+                    "Ignoring exception while closing %s.", name, exc_info=True
+                )
 
     def _release_dxgi_surface(self) -> None:
         # The pointer returned by winrt interop behaves like a borrowed pointer in
@@ -567,7 +543,7 @@ class WinRTDuplicator:
         self._winrt_device = None
 
     def __repr__(self) -> str:
-        return "<{} Initalized:{}>".format(
+        return "<{} Initialized:{}>".format(
             self.__class__.__name__,
             self._session is not None,
         )