feat: CaptureBuilder + hide some fields

Author: modelflat

zbl/examples/directx_interop.rs

@@ -2,7 +2,7 @@ use std::time::Instant;
 
 use clap::Parser;
 use opencv::{core::UMat, highgui};
-use zbl::{Capturable, Capture, Display, Window};
+use zbl::{Capturable, CaptureBuilder, Display, Window};
 
 #[derive(Parser, Debug)]
 #[clap(version)]
@@ -28,9 +28,12 @@ fn main() {
         panic!("either --window-name or --display-id should be set!");
     };
 
-    let mut capture =
-        Capture::new(target, false, true, false).expect("failed to initialize capture");
-    opencv::core::initialize_context_from_d3d11_device(&mut capture.d3d.device)
+    let mut capture = CaptureBuilder::new(target)
+        .set_cpu_access(false)
+        .build()
+        .expect("failed to initialize capture");
+
+    opencv::core::initialize_context_from_d3d11_device(&mut capture.d3d().device)
         .expect("initialize d3d11");
 
     capture.start().expect("failed to start capture");

zbl/examples/simple.rs

@@ -6,7 +6,7 @@ use opencv::{
     highgui,
 };
 use windows::Win32::Foundation::HWND;
-use zbl::{Capturable, Capture, Display, Window};
+use zbl::{capture::CaptureBuilder, Capturable, Display, Window};
 
 #[derive(Parser, Debug)]
 #[clap(version)]
@@ -39,8 +39,9 @@ fn main() {
         panic!("either --window-name or --display-id should be set!");
     };
 
-    let mut capture =
-        Capture::new(target, false, true, true).expect("failed to initialize capture");
+    let mut capture = CaptureBuilder::new(target)
+        .build()
+        .expect("failed to initialize capture");
 
     capture.start().expect("failed to start capture");
 

zbl/src/capture/mod.rs

@@ -32,15 +32,58 @@ pub trait Capturable {
     fn get_raw_handle(&self) -> isize;
 }
 
+pub struct CaptureBuilder {
+    capturable: Box<dyn Capturable>,
+    is_cursor_capture_enabled: bool,
+    is_border_required: bool,
+    cpu_access: bool,
+}
+
+impl CaptureBuilder {
+    pub fn new(capturable: Box<dyn Capturable>) -> Self {
+        Self {
+            capturable,
+            is_cursor_capture_enabled: false,
+            is_border_required: true,
+            cpu_access: true,
+        }
+    }
+
+    pub fn set_is_cursor_capture_enabled(mut self, val: bool) -> Self {
+        self.is_cursor_capture_enabled = val;
+        self
+    }
+
+    pub fn set_is_border_required(mut self, val: bool) -> Self {
+        self.is_border_required = val;
+        self
+    }
+
+    pub fn set_cpu_access(mut self, val: bool) -> Self {
+        self.cpu_access = val;
+        self
+    }
+
+    pub fn build(self) -> Result<Capture> {
+        Capture::new(
+            self.capturable,
+            self.is_cursor_capture_enabled,
+            self.is_border_required,
+            self.cpu_access,
+        )
+    }
+}
+
+/// Represents a Capture session.
 pub struct Capture {
-    pub d3d: D3D,
+    d3d: D3D,
     capturable: Box<dyn Capturable>,
     capture_box: D3D11_BOX,
     capture_done_signal: Receiver<()>,
     frame_pool: Direct3D11CaptureFramePool,
     frame_source: Receiver<Option<Direct3D11CaptureFrame>>,
     session: GraphicsCaptureSession,
-    pub cpu_access: bool,
+    cpu_access: bool,
     staging_texture: Option<ID3D11Texture2D>,
     content_size: SizeInt32,
     stopped: bool,
@@ -51,7 +94,7 @@ impl Capture {
     /// frame pool / capture session.
     ///
     /// Note that this will not start capturing yet. Call `start()` to actually start receiving frames.
-    pub fn new(
+    pub(crate) fn new(
         capturable: Box<dyn Capturable>,
         is_cursor_capture_enabled: bool,
         is_border_required: bool,
@@ -119,6 +162,16 @@ impl Capture {
         })
     }
 
+    /// Get D3D contexts
+    pub fn d3d(&mut self) -> &mut D3D {
+        &mut self.d3d
+    }
+
+    /// Whether the backing buffer of this instance of `Capture` is CPU-accessible.
+    pub fn has_cpu_access(&self) -> bool {
+        self.cpu_access
+    }
+
     /// Get attached capturable.
     pub fn capturable(&self) -> &dyn Capturable {
         self.capturable.as_ref()

zbl/src/lib.rs

@@ -3,7 +3,7 @@ pub mod d3d;
 pub mod frame;
 pub mod util;
 
-pub use capture::{display::Display, window::Window, Capturable, Capture};
+pub use capture::{display::Display, window::Window, Capturable, Capture, CaptureBuilder};
 pub use frame::Frame;
 
 // re-export winapi

zbl_py/src/lib.rs

@@ -66,12 +66,11 @@ impl Capture {
         cpu_access: bool,
     ) -> Result<Self> {
         ::zbl::init();
-        let capture = ::zbl::Capture::new(
-            capturable,
-            is_cursor_capture_enabled,
-            is_border_required,
-            cpu_access,
-        )?;
+        let capture = ::zbl::CaptureBuilder::new(capturable)
+            .set_is_cursor_capture_enabled(is_cursor_capture_enabled)
+            .set_is_border_required(is_border_required)
+            .set_cpu_access(cpu_access)
+            .build()?;
         Ok(Self { inner: capture })
     }
 
@@ -117,7 +116,7 @@ impl Capture {
                 width: desc.Width,
                 height: desc.Height,
                 row_pitch: frame.mapped_ptr.RowPitch,
-                ptr: if self.inner.cpu_access {
+                ptr: if self.inner.has_cpu_access() {
                     frame.mapped_ptr.pData
                 } else {
                     frame.texture.as_raw()