[+] feat: support capturing single camera and mixing it with screen

Author: heng30

Cargo.lock

@@ -11,9 +11,10 @@
 
 ### Features
 - Share screen via WebRTC
-- Single screen recording
 - Push stream via RTMP
+- Single screen recording
 - Single input device audio recording
+- Capturing a single camera
 - Desktop audio recording
 - Microphone noise reduction
 - Cursor tracking

README.md

@@ -11,14 +11,15 @@
 
 ### 功能
 - 屏幕共享（WebRTC）
+- 支持RTMP推流
 - 单个屏幕录制
 - 单个输入设备录音
+- 捕获单个摄像头
 - 桌面音频录制
 - 麦克风降噪
 - 光标跟随
 - 管理录制视频历史
 - 播放录制的历史视频
-- 支持RTMP推流
 
 ----
 

README.zh-CN.md

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use camera::{
     Rgba,
-    image_composition::{Shape, ShapeBase, ShapeCircle, mix_images},
+    image_composition::{Shape, ShapeBase, ShapeCircle, MixPositionWithPadding, mix_images},
 };
 use image::RgbaImage;
 
@@ -27,7 +27,7 @@ fn main() -> Result<()> {
     let circle1 = ShapeCircle::default().with_radius(100).with_base(
         ShapeBase::default()
             .with_border_width(3)
-            .with_pos((0.1, 0.1))
+            .with_pos(MixPositionWithPadding::TopLeft((30, 30)))
             .with_zoom(1.0)
             .with_border_color(Rgba([255, 0, 0, 255]))
             .with_clip_pos((0.5, 0.5)),

lib/camera/examples/circle_demo.rs

@@ -1,7 +1,8 @@
 use camera::{
     Rgba,
     image_composition::{
-        Shape, ShapeBase, ShapeCircle, ShapeRectangle, mix_images, mix_images_rgb,
+        MixPositionWithPadding, Shape, ShapeBase, ShapeCircle, ShapeRectangle, mix_images,
+        mix_images_rgb,
     },
 };
 use image::{RgbImage, RgbaImage};
@@ -29,7 +30,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     log::info!("RGBA: Compositing with rectangle shape...");
     let rect = ShapeRectangle::default().with_size((300, 225)).with_base(
         ShapeBase::default()
-            .with_pos((0.3, 0.3))
+            .with_pos(MixPositionWithPadding::TopLeft((240, 180)))
             .with_border_width(10)
             .with_border_color(Rgba([255, 255, 255, 255])),
     );
@@ -44,7 +45,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     log::info!("RGBA: Compositing with circle shape...");
     let circle = ShapeCircle::default().with_radius(150).with_base(
         ShapeBase::default()
-            .with_pos((0.7, 0.6))
+            .with_pos(MixPositionWithPadding::TopRight((210, 90)))
             .with_border_width(8)
             .with_border_color(Rgba([255, 255, 255, 255])),
     );
@@ -77,7 +78,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     log::info!("RGB: Compositing with rectangle shape...");
     let rect_rgb = ShapeRectangle::default().with_size((300, 225)).with_base(
         ShapeBase::default()
-            .with_pos((0.3, 0.3))
+            .with_pos(MixPositionWithPadding::TopLeft((240, 180)))
             .with_border_width(10)
             .with_border_color(Rgba([255, 255, 255, 255])),
     );
@@ -92,7 +93,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     log::info!("RGB: Compositing with circle shape...");
     let circle_rgb = ShapeCircle::default().with_radius(150).with_base(
         ShapeBase::default()
-            .with_pos((0.7, 0.6))
+            .with_pos(MixPositionWithPadding::TopRight((210, 90)))
             .with_border_width(8)
             .with_border_color(Rgba([255, 255, 255, 255])),
     );
@@ -107,7 +108,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     log::info!("RGB: Compositing with plain rectangle (no border)...");
     let plain_rect_rgb = ShapeRectangle::default().with_size((250, 200)).with_base(
         ShapeBase::default()
-            .with_pos((0.5, 0.5))
+            .with_pos(MixPositionWithPadding::TopLeft((400, 300)))
             .with_border_width(0)
             .with_border_color(Rgba([0, 0, 0, 0])),
     );
@@ -119,6 +120,21 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     result_plain_rgb.save("tmp/composition_rect_plain_rgb.png")?;
     log::info!("Saved RGB output to: tmp/composition_rect_plain_rgb.png");
 
+    log::info!("RGB: Compositing with plain circle (no border)...");
+    let plain_circle_rgb = ShapeCircle::default().with_radius(100).with_base(
+        ShapeBase::default()
+            .with_pos(MixPositionWithPadding::TopLeft((200, 300)))
+            .with_border_width(0)
+            .with_border_color(Rgba([0, 0, 0, 0])),
+    );
+    let result_plain_rgb = mix_images_rgb(
+        background_rgb.clone(),
+        camera_image_rgb.clone(),
+        Shape::Circle(plain_circle_rgb),
+    )?;
+    result_plain_rgb.save("tmp/composition_circle_plain_rgb.png")?;
+    log::info!("Saved RGB output to: tmp/composition_circle_plain_rgb.png");
+
     log::info!("");
     log::info!("All RGBA and RGB examples completed successfully!");
     Ok(())

lib/camera/examples/image_composition_demo.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use camera::{
     Rgba,
-    image_composition::{Shape, ShapeBase, ShapeRectangle, mix_images},
+    image_composition::{Shape, ShapeBase, ShapeRectangle, MixPositionWithPadding, mix_images},
 };
 use image::RgbaImage;
 
@@ -22,7 +22,7 @@ fn main() -> Result<()> {
     let rect1 = ShapeRectangle::default().with_size((100, 50)).with_base(
         ShapeBase::default()
             .with_border_width(3)
-            .with_pos((0.1, 0.1))
+            .with_pos(MixPositionWithPadding::TopLeft((40, 30)))
             .with_zoom(2.0)
             .with_border_color(Rgba([255, 0, 0, 255]))
             .with_clip_pos((0.1, 0.1)),
@@ -36,7 +36,7 @@ fn main() -> Result<()> {
     let rect2 = ShapeRectangle::default().with_size((100, 50)).with_base(
         ShapeBase::default()
             .with_border_width(3)
-            .with_pos((0.6, 0.6))
+            .with_pos(MixPositionWithPadding::TopLeft((240, 180)))
             .with_zoom(2.0)
             .with_border_color(Rgba([255, 0, 0, 255]))
             .with_clip_pos((0.25, 0.25)),

lib/camera/examples/rectangle-demo.rs

@@ -15,14 +15,23 @@ enum BorderShape {
     Rectangle { width: u32, height: u32 },
 }
 
+#[derive(Debug, Clone, Copy)]
+pub enum MixPositionWithPadding {
+    TopLeft((u32, u32)),     // top padding and left padding
+    TopRight((u32, u32)),    // top padding and right padding
+    BottomLeft((u32, u32)),  // bottom padding and left padding
+    BottomRight((u32, u32)), // bottom padding and right padding
+}
+
 #[derive(Debug, Clone, Copy, Derivative, Setters)]
 #[derivative(Default)]
 #[setters(prefix = "with_")]
 #[non_exhaustive]
 pub struct ShapeBase {
-    /// Position in background_image [0, 1] range
-    #[derivative(Default(value = "(0.5, 0.5)"))]
-    pub pos: (f32, f32),
+    /// Position of the shape on the background image
+    /// Specifies padding from the background edges
+    #[derivative(Default(value = "MixPositionWithPadding::BottomRight((32, 32))"))]
+    pub pos: MixPositionWithPadding,
 
     /// Border width in pixels
     #[derivative(Default(value = "2"))]
@@ -60,7 +69,6 @@ pub struct ShapeCircle {
 pub struct ShapeRectangle {
     pub base: ShapeBase,
 
-    /// Size (width, height) in pixels
     #[derivative(Default(value = "(100, 100)"))]
     pub size: (u32, u32),
 }
@@ -106,10 +114,30 @@ where
     let (bg_width, bg_height) = background.dimensions();
     let radius = circle.radius;
     let diameter = (radius * 2) as u32;
-    let center_x =
-        ((circle.base.pos.0 * bg_width as f32) as u32).clamp(radius, bg_width as u32 - radius);
-    let center_y =
-        ((circle.base.pos.1 * bg_height as f32) as u32).clamp(radius, bg_height as u32 - radius);
+
+    // Calculate center position based on MixPositionWithPadding
+    let (center_x, center_y) = match circle.base.pos {
+        MixPositionWithPadding::TopLeft((pad_top, pad_left)) => {
+            let cx = (pad_left + radius).min(bg_width - radius);
+            let cy = (pad_top + radius).min(bg_height - radius);
+            (cx.max(radius), cy.max(radius))
+        }
+        MixPositionWithPadding::TopRight((pad_top, pad_right)) => {
+            let cx = bg_width.saturating_sub(pad_right + radius).max(radius);
+            let cy = (pad_top + radius).min(bg_height - radius);
+            (cx.min(bg_width - radius), cy.max(radius))
+        }
+        MixPositionWithPadding::BottomLeft((pad_bottom, pad_left)) => {
+            let cx = (pad_left + radius).min(bg_width - radius);
+            let cy = bg_height.saturating_sub(pad_bottom + radius).max(radius);
+            (cx.max(radius), cy.min(bg_height - radius))
+        }
+        MixPositionWithPadding::BottomRight((pad_bottom, pad_right)) => {
+            let cx = bg_width.saturating_sub(pad_right + radius).max(radius);
+            let cy = bg_height.saturating_sub(pad_bottom + radius).max(radius);
+            (cx.min(bg_width - radius), cy.min(bg_height - radius))
+        }
+    };
 
     let cropped_camera = crop_image_by_pixel_type(
         camera_image,
@@ -181,10 +209,31 @@ where
     P: Pixel<Subpixel = u8> + Copy,
 {
     let (bg_width, bg_height) = background.dimensions();
-    let x = (rect.base.pos.0 * bg_width as f32) as u32;
-    let y = (rect.base.pos.1 * bg_height as f32) as u32;
     let (width, height) = rect.size;
 
+    // Calculate top-left position based on MixPositionWithPadding
+    let (x, y) = match rect.base.pos {
+        MixPositionWithPadding::TopLeft((pad_top, pad_left)) => (
+            pad_left.min(bg_width.saturating_sub(width)),
+            pad_top.min(bg_height.saturating_sub(height)),
+        ),
+        MixPositionWithPadding::TopRight((pad_top, pad_right)) => {
+            let x = bg_width.saturating_sub(width + pad_right);
+            let y = pad_top.min(bg_height.saturating_sub(height));
+            (x, y)
+        }
+        MixPositionWithPadding::BottomLeft((pad_bottom, pad_left)) => {
+            let x = pad_left.min(bg_width.saturating_sub(width));
+            let y = bg_height.saturating_sub(height + pad_bottom);
+            (x, y)
+        }
+        MixPositionWithPadding::BottomRight((pad_bottom, pad_right)) => {
+            let x = bg_width.saturating_sub(width + pad_right);
+            let y = bg_height.saturating_sub(height + pad_bottom);
+            (x, y)
+        }
+    };
+
     let cropped_camera = crop_image_by_pixel_type(
         camera_image,
         width,
@@ -193,15 +242,14 @@ where
         rect.base.clip_pos,
     )?;
 
+    let width = width.min(bg_width.saturating_sub(x));
+    let height = height.min(bg_height.saturating_sub(y));
+
     for cam_y in 0..height {
         for cam_x in 0..width {
             let bg_x = x + cam_x;
             let bg_y = y + cam_y;
 
-            if bg_x >= bg_width || bg_y >= bg_height {
-                continue;
-            }
-
             let cam_pixel = cropped_camera.get_pixel(cam_x, cam_y);
             background.put_pixel(bg_x, bg_y, *cam_pixel);
         }
@@ -314,25 +362,40 @@ where
     // If the cropped image is smaller than target, pad with black
     if actual_crop_width < target_width || actual_crop_height < target_height {
         let mut result = ImageBuffer::new(target_width, target_height);
+
+        // Calculate offset position in target canvas based on clip_pos
+        let offset_x =
+            ((target_width - actual_crop_width) as f32 * clip_pos.0.clamp(0.0, 1.0)).round() as u32;
+        let offset_y = ((target_height - actual_crop_height) as f32 * clip_pos.1.clamp(0.0, 1.0))
+            .round() as u32;
+
         for y in 0..target_height {
             for x in 0..target_width {
-                if x < actual_crop_width && y < actual_crop_height {
-                    let idx = (y * actual_crop_width + x) as usize * channel_count;
-                    let mut channels = [0u8; 4];
-                    for c in 0..channel_count {
-                        channels[c] = cropped_buffer[idx + c];
-                    }
-                    // Fill remaining channels with 255 (alpha) or 0
-                    for c in channel_count..4 {
-                        channels[c] = if c == 3 { 255 } else { 0 };
+                // Check if current pixel is within the image area (offset-adjusted)
+                let rel_x = x.checked_sub(offset_x);
+                let rel_y = y.checked_sub(offset_y);
+
+                if let (Some(rx), Some(ry)) = (rel_x, rel_y) {
+                    if rx < actual_crop_width && ry < actual_crop_height {
+                        let idx = (ry * actual_crop_width + rx) as usize * channel_count;
+                        let mut channels = [0u8; 4];
+                        for c in 0..channel_count {
+                            channels[c] = cropped_buffer[idx + c];
+                        }
+                        // Fill remaining channels with 255 (alpha) or 0
+                        for c in channel_count..4 {
+                            channels[c] = if c == 3 { 255 } else { 0 };
+                        }
+                        let pixel = P::from_slice(&channels[..channel_count]);
+                        result.put_pixel(x, y, *pixel);
+                        continue;
                     }
-                    let pixel = P::from_slice(&channels[..channel_count]);
-                    result.put_pixel(x, y, *pixel);
-                } else {
-                    let black = [0u8; 4];
-                    let pixel = P::from_slice(&black[..channel_count]);
-                    result.put_pixel(x, y, *pixel);
                 }
+
+                // Pad with black
+                let black = [0u8; 4];
+                let pixel = P::from_slice(&black[..channel_count]);
+                result.put_pixel(x, y, *pixel);
             }
         }
         Ok(result)

lib/camera/src/image_composition.rs

@@ -5,7 +5,10 @@ pub mod image_composition;
 pub use camera_client::{CameraClient, CameraConfig, PixelFormat};
 pub use camera_info::{CameraInfo, query_available_cameras, query_camera_id, query_first_camera};
 pub use image::{ImageBuffer, Rgb, Rgba, RgbaImage};
-pub use image_composition::{Shape, ShapeCircle, ShapeRectangle, mix_images, mix_images_rgb};
+pub use image_composition::{
+    MixPositionWithPadding, Shape, ShapeBase, ShapeCircle, ShapeRectangle, mix_images,
+    mix_images_rgb,
+};
 
 pub type CameraResult<T> = Result<T, CameraError>;
 

lib/camera/src/lib.rs

@@ -194,12 +194,14 @@ impl PushStreamConfig {
 pub struct CameraMixConfig {
     pub enable: bool,
     pub camera_name: Option<String>,
+
+    pub fps: u32,
     pub width: u32,
     pub height: u32,
-    pub fps: u32,
+    pub mirror_horizontal: bool,
     pub pixel_format: camera::PixelFormat,
+
     pub shape: Shape,
-    pub mirror_horizontal: bool,
 }
 
 impl Default for CameraMixConfig {

lib/recorder/src/config.rs

@@ -530,10 +530,10 @@ impl RecordingSession {
 
         let (camera_image_sender, camera_image_receiver) = bounded(5);
         let camera_config = CameraConfig::default()
-            .with_pixel_format(camera::PixelFormat::RGB)
             .with_fps(self.config.camera_mix_config.fps)
             .with_width(self.config.camera_mix_config.width)
             .with_height(self.config.camera_mix_config.height)
+            .with_pixel_format(self.config.camera_mix_config.pixel_format)
             .with_mirror_horizontal(self.config.camera_mix_config.mirror_horizontal);
 
         let mut camera_client = CameraClient::new(camera_index, camera_config)?;