Initialize Vulkan directly from wlroots, refactor out the processor trait

Author: maximbaz

src/frame/capturer/wlroots.rs

@@ -1,4 +1,4 @@
-use crate::frame::{object::Object, processor::Processor};
+use crate::frame::{object::Object, vulkan::Vulkan};
 use crate::predictor::Controller;
 use std::{cell::RefCell, rc::Rc, thread, time::Duration};
 use wayland_client::{
@@ -21,7 +21,7 @@ pub struct Capturer {
     event_queue: Rc<RefCell<EventQueue>>,
     globals: GlobalManager,
     dmabuf_manager: Main<ZwlrExportDmabufManagerV1>,
-    processor: Rc<dyn Processor>,
+    vulkan: Rc<Vulkan>,
     registry: Main<WlRegistry>,
     xdg_output_manager: Main<ZxdgOutputManagerV1>,
 }
@@ -65,8 +65,8 @@ impl super::Capturer for Capturer {
     }
 }
 
-impl Capturer {
-    pub fn new(processor: Box<dyn Processor>) -> Self {
+impl Default for Capturer {
+    fn default() -> Self {
         let display = Display::connect_to_env().unwrap();
         let mut event_queue = display.create_event_queue();
         let attached_display = display.attach(event_queue.token());
@@ -83,16 +83,20 @@ impl Capturer {
             .instantiate_exact::<ZxdgOutputManagerV1>(3)
             .expect("Unable to init xdg_output_manager");
 
+        let vulkan = Rc::new(Vulkan::new().expect("Unable to initialize Vulkan"));
+
         Self {
             event_queue: Rc::new(RefCell::new(event_queue)),
             globals,
             registry,
             dmabuf_manager,
-            processor: processor.into(),
+            vulkan,
             xdg_output_manager,
         }
     }
+}
 
+impl Capturer {
     fn capture_frame(
         self: Rc<Self>,
         controller: Rc<RefCell<Controller>>,
@@ -119,7 +123,7 @@ impl Capturer {
 
                 Event::Ready { .. } => {
                     let luma = self
-                        .processor
+                        .vulkan
                         .luma_percent(&frame)
                         .expect("Unable to compute luma percent");
 

src/frame/mod.rs

@@ -2,7 +2,7 @@ use itertools::Itertools;
 
 pub mod capturer;
 mod object;
-pub mod processor;
+pub mod vulkan;
 
 pub fn compute_perceived_lightness_percent(rgbas: &[u8], has_alpha: bool, pixels: usize) -> u8 {
     let channels = if has_alpha { 4 } else { 3 };

src/frame/processor/mod.rs

@@ -14,7 +14,7 @@ const FINAL_MIP_LEVEL: u32 = 4; // Don't generate mipmaps beyond this level - GP
 const BUFFER_PIXELS: u64 = 500 * 4; // Pre-allocated buffer size, should be enough to fit FINAL_MIP_LEVEL
 const FENCES_TIMEOUT_NS: u64 = 1_000_000_000;
 
-pub struct Processor {
+pub struct Vulkan {
     _entry: Entry, // must keep reference to prevent early memory release
     instance: Instance,
     device: Device,
@@ -29,63 +29,7 @@ pub struct Processor {
     image_resolution: RefCell<Option<(u32, u32)>>,
 }
 
-impl super::Processor for Processor {
-    fn luma_percent(&self, frame: &Object) -> Result<u8, Box<dyn Error>> {
-        assert_eq!(
-            1, frame.num_objects,
-            "Frames with multiple objects are not supported yet"
-        );
-
-        if self.image.borrow().is_none() {
-            self.init_image(frame)?;
-        }
-        assert_eq!(
-            (frame.width, frame.height),
-            self.image_resolution.borrow().unwrap(),
-            "Handling screen resolution change is not supported yet"
-        );
-
-        let image = self
-            .image
-            .borrow()
-            .ok_or("Unable to borrow the Vulkan image")?;
-
-        let (frame_image, frame_image_memory) = self.init_frame_image(frame)?;
-
-        self.begin_commands()?;
-
-        let (target_mip_level, mip_width, mip_height) =
-            self.generate_mipmaps(frame, &frame_image, &image);
-
-        self.copy_mipmap(&image, target_mip_level, mip_width, mip_height);
-
-        self.submit_commands()?;
-
-        let pixels = mip_width as usize * mip_height as usize;
-        let rgbas = unsafe {
-            let buffer_pointer = self.device.map_memory(
-                self.buffer_memory,
-                0,
-                vk::WHOLE_SIZE,
-                vk::MemoryMapFlags::empty(),
-            )?;
-            std::slice::from_raw_parts(buffer_pointer as *mut u8, pixels * 4)
-        };
-
-        let result = compute_perceived_lightness_percent(rgbas, true, pixels);
-
-        unsafe {
-            self.device.unmap_memory(self.buffer_memory);
-            self.device.reset_fences(&[self.fence])?;
-            self.device.destroy_image(frame_image, None);
-            self.device.free_memory(frame_image_memory, None);
-        }
-
-        Ok(result)
-    }
-}
-
-impl Processor {
+impl Vulkan {
     pub fn new() -> Result<Self, Box<dyn Error>> {
         let app_name = CString::new("wluma")?;
         let app_info = vk::ApplicationInfo::builder()
@@ -197,6 +141,60 @@ impl Processor {
         })
     }
 
+    pub fn luma_percent(&self, frame: &Object) -> Result<u8, Box<dyn Error>> {
+        assert_eq!(
+            1, frame.num_objects,
+            "Frames with multiple objects are not supported yet"
+        );
+
+        if self.image.borrow().is_none() {
+            self.init_image(frame)?;
+        }
+        assert_eq!(
+            (frame.width, frame.height),
+            self.image_resolution.borrow().unwrap(),
+            "Handling screen resolution change is not supported yet"
+        );
+
+        let image = self
+            .image
+            .borrow()
+            .ok_or("Unable to borrow the Vulkan image")?;
+
+        let (frame_image, frame_image_memory) = self.init_frame_image(frame)?;
+
+        self.begin_commands()?;
+
+        let (target_mip_level, mip_width, mip_height) =
+            self.generate_mipmaps(frame, &frame_image, &image);
+
+        self.copy_mipmap(&image, target_mip_level, mip_width, mip_height);
+
+        self.submit_commands()?;
+
+        let pixels = mip_width as usize * mip_height as usize;
+        let rgbas = unsafe {
+            let buffer_pointer = self.device.map_memory(
+                self.buffer_memory,
+                0,
+                vk::WHOLE_SIZE,
+                vk::MemoryMapFlags::empty(),
+            )?;
+            std::slice::from_raw_parts(buffer_pointer as *mut u8, pixels * 4)
+        };
+
+        let result = compute_perceived_lightness_percent(rgbas, true, pixels);
+
+        unsafe {
+            self.device.unmap_memory(self.buffer_memory);
+            self.device.reset_fences(&[self.fence])?;
+            self.device.destroy_image(frame_image, None);
+            self.device.free_memory(frame_image_memory, None);
+        }
+
+        Ok(result)
+    }
+
     fn init_image(&self, frame: &Object) -> Result<(), Box<dyn Error>> {
         let (width, height, mip_levels) = image_dimensions(frame);
 
@@ -525,7 +523,7 @@ impl Processor {
     }
 }
 
-impl Drop for Processor {
+impl Drop for Vulkan {
     fn drop(&mut self) {
         unsafe {
             self.device

src/frame/processor/vulkan.rs renamed to src/frame/vulkan.rs

@@ -67,15 +67,11 @@ fn main() {
                     std::thread::Builder::new()
                         .name(thread_name.clone())
                         .spawn(move || {
-                            let frame_processor = Box::new(
-                                frame::processor::vulkan::Processor::new()
-                                    .expect("Unable to initialize Vulkan"),
-                            );
                             let frame_capturer: Box<dyn frame::capturer::Capturer> =
                                 match output_capturer {
-                                    config::Capturer::Wlroots => Box::new(
-                                        frame::capturer::wlroots::Capturer::new(frame_processor),
-                                    ),
+                                    config::Capturer::Wlroots => {
+                                        Box::new(frame::capturer::wlroots::Capturer::default())
+                                    }
                                     config::Capturer::None => {
                                         Box::new(frame::capturer::none::Capturer::default())
                                     }