zero copy and get direct3d device and context

examples/basic.rs

@@ -4,7 +4,7 @@ use std::{
 };
 
 use windows_capture::{
-    capture::GraphicsCaptureApiHandler,
+    capture::{GraphicsCaptureApiHandler, RawDirect3DDevice},
     encoder::{AudioSettingsBuilder, ContainerSettingsBuilder, VideoEncoder, VideoSettingsBuilder},
     frame::Frame,
     graphics_capture_api::InternalCaptureControl,
@@ -28,7 +28,7 @@ impl GraphicsCaptureApiHandler for Capture {
     type Error = Box<dyn std::error::Error + Send + Sync>;
 
     // Function that will be called to create the struct. The flags can be passed from settings.
-    fn new(message: Self::Flags) -> Result<Self, Self::Error> {
+    fn new(_: RawDirect3DDevice, message: Self::Flags) -> Result<Self, Self::Error> {
         println!("Got The Flag: {message}");
 
         let encoder = VideoEncoder::new(

examples/cli.rs

@@ -10,10 +10,8 @@ use std::{
 use clap::Parser;
 
 use windows_capture::{
-    capture::GraphicsCaptureApiHandler,
-    encoder::{
-        AudioSettingsBuilder, ContainerSettingsBuilder, VideoEncoder, VideoSettingsBuilder,
-    },
+    capture::{GraphicsCaptureApiHandler, RawDirect3DDevice},
+    encoder::{AudioSettingsBuilder, ContainerSettingsBuilder, VideoEncoder, VideoSettingsBuilder},
     frame::Frame,
     graphics_capture_api::InternalCaptureControl,
     monitor::Monitor,
@@ -55,7 +53,7 @@ impl GraphicsCaptureApiHandler for Capture {
     type Error = Box<dyn std::error::Error + Send + Sync>;
 
     // Function that will be called to create the struct. The flags can be passed from settings.
-    fn new(settings: Self::Flags) -> Result<Self, Self::Error> {
+    fn new(_: RawDirect3DDevice, settings: Self::Flags) -> Result<Self, Self::Error> {
         println!("Capture started.");
 
         let video_settings = VideoSettingsBuilder::new(settings.width, settings.height)
@@ -226,8 +224,7 @@ fn main() {
 
     if let Some(window_name) = cli.window_name {
         // May use Window::foreground() instead
-        let capture_item =
-            Window::from_contains_name(&window_name).expect("Window not found!");
+        let capture_item = Window::from_contains_name(&window_name).expect("Window not found!");
 
         // Automatically detect window's width and height
         let rect = capture_item.rect().expect("Failed to get window rect");
@@ -249,12 +246,7 @@ fn main() {
         );
         println!("Window size: {}x{}", width, height);
 
-        start_capture(
-            capture_item,
-            cursor_capture,
-            draw_border,
-            capture_settings,
-        );
+        start_capture(capture_item, cursor_capture, draw_border, capture_settings);
     } else if let Some(index) = cli.monitor_index {
         // May use Monitor::primary() instead
         let capture_item =
@@ -276,12 +268,7 @@ fn main() {
         println!("Monitor index: {}", index);
         println!("Monitor size: {}x{}", width, height);
 
-        start_capture(
-            capture_item,
-            cursor_capture,
-            draw_border,
-            capture_settings,
-        );
+        start_capture(capture_item, cursor_capture, draw_border, capture_settings);
     } else {
         eprintln!("Either --window-name or --monitor-index must be provided");
         std::process::exit(1);

src/capture.rs

@@ -14,6 +14,7 @@ use windows::{
     Graphics::Capture::GraphicsCaptureItem,
     Win32::{
         Foundation::{HANDLE, LPARAM, WPARAM},
+        Graphics::Direct3D11::{ID3D11Device, ID3D11DeviceContext},
         System::{
             Threading::{GetCurrentThreadId, GetThreadId},
             WinRT::{
@@ -29,6 +30,7 @@ use windows::{
 };
 
 use crate::{
+    d3d11::{self, create_d3d_device},
     frame::Frame,
     graphics_capture_api::{self, GraphicsCaptureApi, InternalCaptureControl},
     settings::Settings,
@@ -207,6 +209,8 @@ pub enum GraphicsCaptureApiError<E> {
     FailedToSetDispatcherQueueCompletedHandler,
     #[error("Failed to convert item to GraphicsCaptureItem")]
     ItemConvertFailed,
+    #[error("DirectX error: {0}")]
+    DirectXError(#[from] d3d11::Error),
     #[error("Graphics capture error: {0}")]
     GraphicsCaptureApiError(graphics_capture_api::Error),
     #[error("New handler error: {0}")]
@@ -261,10 +265,20 @@ pub trait GraphicsCaptureApiHandler: Sized {
         // Get current thread ID
         let thread_id = unsafe { GetCurrentThreadId() };
 
+        // Create direct3d device and context
+        let (d3d_device, d3d_device_context) = create_d3d_device()?;
+
         // Start capture
         let result = Arc::new(Mutex::new(None));
         let callback = Arc::new(Mutex::new(
-            Self::new(settings.flags).map_err(GraphicsCaptureApiError::NewHandlerError)?,
+            Self::new(
+                RawDirect3DDevice {
+                    device: d3d_device.clone(),
+                    context: d3d_device_context.clone(),
+                },
+                settings.flags,
+            )
+            .map_err(GraphicsCaptureApiError::NewHandlerError)?,
         ));
 
         let item = settings
@@ -273,6 +287,8 @@ pub trait GraphicsCaptureApiHandler: Sized {
             .map_err(|_| GraphicsCaptureApiError::ItemConvertFailed)?;
 
         let mut capture = GraphicsCaptureApi::new(
+            d3d_device,
+            d3d_device_context,
             item,
             callback,
             settings.cursor_capture,
@@ -374,10 +390,20 @@ pub trait GraphicsCaptureApiHandler: Sized {
                 // Get current thread ID
                 let thread_id = unsafe { GetCurrentThreadId() };
 
+                // Create direct3d device and context
+                let (d3d_device, d3d_device_context) = create_d3d_device()?;
+
                 // Start capture
                 let result = Arc::new(Mutex::new(None));
                 let callback = Arc::new(Mutex::new(
-                    Self::new(settings.flags).map_err(GraphicsCaptureApiError::NewHandlerError)?,
+                    Self::new(
+                        RawDirect3DDevice {
+                            device: d3d_device.clone(),
+                            context: d3d_device_context.clone(),
+                        },
+                        settings.flags,
+                    )
+                    .map_err(GraphicsCaptureApiError::NewHandlerError)?,
                 ));
 
                 let item = settings
@@ -386,6 +412,8 @@ pub trait GraphicsCaptureApiHandler: Sized {
                     .map_err(|_| GraphicsCaptureApiError::ItemConvertFailed)?;
 
                 let mut capture = GraphicsCaptureApi::new(
+                    d3d_device,
+                    d3d_device_context,
                     item,
                     callback.clone(),
                     settings.cursor_capture,
@@ -485,7 +513,7 @@ pub trait GraphicsCaptureApiHandler: Sized {
     /// # Returns
     ///
     /// Returns `Ok(Self)` if the struct creation was successful, otherwise returns an error of type `Self::Error`.
-    fn new(flags: Self::Flags) -> Result<Self, Self::Error>;
+    fn new(device: RawDirect3DDevice, flags: Self::Flags) -> Result<Self, Self::Error>;
 
     /// Called every time a new frame is available.
     ///
@@ -513,3 +541,9 @@ pub trait GraphicsCaptureApiHandler: Sized {
         Ok(())
     }
 }
+
+#[derive(Clone)]
+pub struct RawDirect3DDevice {
+    pub device: ID3D11Device,
+    pub context: ID3D11DeviceContext,
+}

src/encoder.rs

@@ -991,7 +991,9 @@ impl VideoEncoder {
         };
 
         self.frame_sender.send(Some((
-            VideoEncoderSource::DirectX(SendDirectX::new(unsafe { frame.as_raw_surface() })),
+            VideoEncoderSource::DirectX(SendDirectX::new(unsafe {
+                frame.as_raw_surface().clone()
+            })),
             timespan,
         )))?;
 
@@ -1051,7 +1053,9 @@ impl VideoEncoder {
         };
 
         self.frame_sender.send(Some((
-            VideoEncoderSource::DirectX(SendDirectX::new(unsafe { frame.as_raw_surface() })),
+            VideoEncoderSource::DirectX(SendDirectX::new(unsafe {
+                frame.as_raw_surface().clone()
+            })),
             timespan,
         )))?;
 

src/frame.rs

@@ -168,8 +168,8 @@ impl<'a> Frame<'a> {
     /// This method is unsafe because it returns a raw pointer to the IDirect3DSurface.
     #[must_use]
     #[inline]
-    pub unsafe fn as_raw_surface(&self) -> IDirect3DSurface {
-        self.frame_surface.clone()
+    pub unsafe fn as_raw_surface(&self) -> &IDirect3DSurface {
+        &self.frame_surface
     }
 
     /// Get the raw texture of the frame.
@@ -178,7 +178,17 @@ impl<'a> Frame<'a> {
     ///
     /// The ID3D11Texture2D representing the raw texture of the frame.
     #[inline]
-    pub fn texture(&self) -> Result<ID3D11Texture2D, Error> {
+    pub unsafe fn as_raw_texture(&self) -> &ID3D11Texture2D {
+        &self.frame_texture
+    }
+
+    /// Get the frame buffer.
+    ///
+    /// # Returns
+    ///
+    /// The FrameBuffer containing the frame data.
+    #[inline]
+    pub fn buffer(&mut self) -> Result<FrameBuffer, Error> {
         // Texture Settings
         let texture_desc = D3D11_TEXTURE2D_DESC {
             Width: self.width,
@@ -192,7 +202,7 @@ impl<'a> Frame<'a> {
             },
             Usage: D3D11_USAGE_STAGING,
             BindFlags: 0,
-            CPUAccessFlags: D3D11_CPU_ACCESS_READ.0 as u32 | D3D11_CPU_ACCESS_WRITE.0 as u32,
+            CPUAccessFlags: D3D11_CPU_ACCESS_READ.0 as u32,
             MiscFlags: 0,
         };
 
@@ -210,18 +220,6 @@ impl<'a> Frame<'a> {
             self.context.CopyResource(&texture, &self.frame_texture);
         };
 
-        Ok(texture)
-    }
-
-    /// Get the frame buffer.
-    ///
-    /// # Returns
-    ///
-    /// The FrameBuffer containing the frame data.
-    #[inline]
-    pub fn buffer(&mut self) -> Result<FrameBuffer, Error> {
-        let texture = self.texture()?;
-
         // Map the texture to enable CPU access
         let mut mapped_resource = D3D11_MAPPED_SUBRESOURCE::default();
         unsafe {

src/graphics_capture_api.rs

@@ -23,7 +23,7 @@ use windows::{
 
 use crate::{
     capture::GraphicsCaptureApiHandler,
-    d3d11::{self, create_d3d_device, create_direct3d_device, SendDirectX},
+    d3d11::{self, create_direct3d_device, SendDirectX},
     frame::Frame,
     settings::{ColorFormat, CursorCaptureSettings, DrawBorderSettings},
 };
@@ -117,6 +117,8 @@ impl GraphicsCaptureApi {
         T: GraphicsCaptureApiHandler<Error = E> + Send + 'static,
         E: Send + Sync + 'static,
     >(
+        d3d_device: ID3D11Device,
+        d3d_device_context: ID3D11DeviceContext,
         item: GraphicsCaptureItem,
         callback: Arc<Mutex<T>>,
         cursor_capture: CursorCaptureSettings,
@@ -141,7 +143,6 @@ impl GraphicsCaptureApi {
         }
 
         // Create DirectX devices
-        let (d3d_device, d3d_device_context) = create_d3d_device()?;
         let direct3d_device = create_direct3d_device(&d3d_device)?;
 
         let pixel_format = DirectXPixelFormat(color_format as i32);

windows-capture-python/src/lib.rs

@@ -8,6 +8,7 @@ use std::sync::Arc;
 use ::windows_capture::{
     capture::{
         CaptureControl, CaptureControlError, GraphicsCaptureApiError, GraphicsCaptureApiHandler,
+        RawDirect3DDevice,
     },
     frame::{self, Frame},
     graphics_capture_api::InternalCaptureControl,
@@ -368,7 +369,10 @@ impl GraphicsCaptureApiHandler for InnerNativeWindowsCapture {
     type Error = InnerNativeWindowsCaptureError;
 
     #[inline]
-    fn new((on_frame_arrived_callback, on_closed): Self::Flags) -> Result<Self, Self::Error> {
+    fn new(
+        _: RawDirect3DDevice,
+        (on_frame_arrived_callback, on_closed): Self::Flags,
+    ) -> Result<Self, Self::Error> {
         Ok(Self {
             on_frame_arrived_callback,
             on_closed,