feat(screenshot): add multi-format image saving support

- Add ImageFormat enum with PNG, JPEG, TIFF, GIF, BMP, and HEIC variants
- Add CGImage::save() method accepting format and quality parameters
- Update save_png() to delegate to save() for consistency
- Add cgimage_save_to_file FFI function with format and quality support

refactor(tests): move inline tests to tests/ directory

- Move audio_devices tests to tests/audio_devices_tests.rs
- Move ffi_string tests to tests/ffi_string_tests.rs
- Move sync_completion tests to tests/sync_completion_tests.rs

Author: 1313

src/audio_devices.rs

@@ -93,32 +93,4 @@ impl AudioInputDevice {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
 
-    #[test]
-    fn test_list_audio_devices() {
-        // Should not panic
-        let devices = AudioInputDevice::list();
-        // On most Macs, there should be at least one built-in microphone
-        println!("Found {} audio input devices", devices.len());
-        for device in &devices {
-            println!(
-                "  {} - {} (default: {})",
-                device.id, device.name, device.is_default
-            );
-        }
-    }
-
-    #[test]
-    fn test_default_device() {
-        // Should not panic
-        if let Some(device) = AudioInputDevice::default_device() {
-            println!("Default device: {} - {}", device.id, device.name);
-            assert!(device.is_default);
-        } else {
-            println!("No default audio input device");
-        }
-    }
-}

src/ffi/mod.rs

@@ -479,6 +479,7 @@ extern "C" {
         sample_buffer_callback: extern "C" fn(*const c_void, *const c_void, i32),
         dispatch_queue: *const c_void,
     ) -> bool;
+    pub fn sc_stream_remove_stream_output(stream: *const c_void, output_type: i32) -> bool;
     pub fn sc_stream_start_capture(
         stream: *const c_void,
         context: *mut c_void,
@@ -684,6 +685,12 @@ extern "C" {
     pub fn cgimage_free_data(ptr: *mut u8);
     pub fn cgimage_release(image: *const c_void);
     pub fn cgimage_save_png(image: *const c_void, path: *const i8) -> bool;
+    pub fn cgimage_save_to_file(
+        image: *const c_void,
+        path: *const i8,
+        format: i32,
+        quality: f32,
+    ) -> bool;
 }
 
 // MARK: - SCScreenshotConfiguration (macOS 26.0+)

src/screenshot_manager.rs

@@ -12,6 +12,71 @@ use std::ffi::c_void;
 #[cfg(feature = "macos_15_2")]
 use crate::cg::CGRect;
 
+/// Image output format for saving screenshots
+///
+/// # Examples
+///
+/// ```no_run
+/// use screencapturekit::screenshot_manager::ImageFormat;
+///
+/// // PNG for lossless quality
+/// let format = ImageFormat::Png;
+///
+/// // JPEG with 80% quality
+/// let format = ImageFormat::Jpeg(0.8);
+///
+/// // HEIC with 90% quality (smaller file size than JPEG)
+/// let format = ImageFormat::Heic(0.9);
+/// ```
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum ImageFormat {
+    /// PNG format (lossless)
+    Png,
+    /// JPEG format with quality (0.0-1.0)
+    Jpeg(f32),
+    /// TIFF format (lossless)
+    Tiff,
+    /// GIF format
+    Gif,
+    /// BMP format
+    Bmp,
+    /// HEIC format with quality (0.0-1.0) - efficient compression
+    Heic(f32),
+}
+
+impl ImageFormat {
+    fn to_format_id(self) -> i32 {
+        match self {
+            Self::Png => 0,
+            Self::Jpeg(_) => 1,
+            Self::Tiff => 2,
+            Self::Gif => 3,
+            Self::Bmp => 4,
+            Self::Heic(_) => 5,
+        }
+    }
+
+    fn quality(self) -> f32 {
+        match self {
+            Self::Jpeg(q) | Self::Heic(q) => q.clamp(0.0, 1.0),
+            _ => 1.0,
+        }
+    }
+
+    /// Get the typical file extension for this format
+    #[must_use]
+    pub const fn extension(&self) -> &'static str {
+        match self {
+            Self::Png => "png",
+            Self::Jpeg(_) => "jpg",
+            Self::Tiff => "tiff",
+            Self::Gif => "gif",
+            Self::Bmp => "bmp",
+            Self::Heic(_) => "heic",
+        }
+    }
+}
+
 extern "C" fn image_callback(
     image_ptr: *const c_void,
     error_ptr: *const i8,
@@ -199,15 +264,62 @@ impl CGImage {
     /// # }
     /// ```
     pub fn save_png(&self, path: &str) -> Result<(), SCError> {
+        self.save(path, ImageFormat::Png)
+    }
+
+    /// Save the image to a file in the specified format
+    ///
+    /// # Arguments
+    /// * `path` - The file path to save the image to
+    /// * `format` - The output format (PNG, JPEG, TIFF, GIF, BMP, or HEIC)
+    ///
+    /// # Errors
+    /// Returns an error if the image cannot be saved
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// # use screencapturekit::screenshot_manager::{SCScreenshotManager, ImageFormat};
+    /// # use screencapturekit::stream::{content_filter::SCContentFilter, configuration::SCStreamConfiguration};
+    /// # use screencapturekit::shareable_content::SCShareableContent;
+    /// # fn example() -> Result<(), Box<dyn std::error::Error>> {
+    /// # let content = SCShareableContent::get()?;
+    /// # let display = &content.displays()[0];
+    /// # let filter = SCContentFilter::builder().display(display).exclude_windows(&[]).build();
+    /// # let config = SCStreamConfiguration::new().with_width(1920).with_height(1080);
+    /// let image = SCScreenshotManager::capture_image(&filter, &config)?;
+    ///
+    /// // Save as PNG (lossless)
+    /// image.save("/tmp/screenshot.png", ImageFormat::Png)?;
+    ///
+    /// // Save as JPEG with 85% quality
+    /// image.save("/tmp/screenshot.jpg", ImageFormat::Jpeg(0.85))?;
+    ///
+    /// // Save as HEIC with 90% quality (smaller file size)
+    /// image.save("/tmp/screenshot.heic", ImageFormat::Heic(0.9))?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn save(&self, path: &str, format: ImageFormat) -> Result<(), SCError> {
         let c_path = std::ffi::CString::new(path)
             .map_err(|_| SCError::internal_error("Path contains null bytes"))?;
 
-        let success = unsafe { crate::ffi::cgimage_save_png(self.ptr, c_path.as_ptr()) };
+        let success = unsafe {
+            crate::ffi::cgimage_save_to_file(
+                self.ptr,
+                c_path.as_ptr(),
+                format.to_format_id(),
+                format.quality(),
+            )
+        };
 
         if success {
             Ok(())
         } else {
-            Err(SCError::internal_error("Failed to save image as PNG"))
+            Err(SCError::internal_error(format!(
+                "Failed to save image as {}",
+                format.extension().to_uppercase()
+            )))
         }
     }
 }

src/utils/ffi_string.rs

@@ -128,42 +128,4 @@ where
     ffi_string_owned(ffi_call).unwrap_or_default()
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
 
-    #[test]
-    fn test_ffi_string_from_buffer_success() {
-        let result = unsafe {
-            ffi_string_from_buffer(64, |buf, _len| {
-                let test_str = b"hello\0";
-                std::ptr::copy_nonoverlapping(test_str.as_ptr(), buf.cast::<u8>(), test_str.len());
-                true
-            })
-        };
-        assert_eq!(result, Some("hello".to_string()));
-    }
-
-    #[test]
-    fn test_ffi_string_from_buffer_failure() {
-        let result = unsafe { ffi_string_from_buffer(64, |_buf, _len| false) };
-        assert_eq!(result, None);
-    }
-
-    #[test]
-    fn test_ffi_string_from_buffer_empty() {
-        let result = unsafe {
-            ffi_string_from_buffer(64, |buf, _len| {
-                *buf = 0; // empty string
-                true
-            })
-        };
-        assert_eq!(result, None);
-    }
-
-    #[test]
-    fn test_ffi_string_or_empty() {
-        let result = unsafe { ffi_string_from_buffer_or_empty(64, |_buf, _len| false) };
-        assert_eq!(result, String::new());
-    }
-}

src/utils/sync_completion.rs

@@ -284,83 +284,4 @@ impl UnitCompletion {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
 
-    #[test]
-    fn test_sync_completion_success() {
-        let (completion, context) = SyncCompletion::<i32>::new();
-
-        // Simulate callback being called (normally from FFI)
-        unsafe { SyncCompletion::complete_ok(context, 42) };
-
-        let result = completion.wait();
-        assert_eq!(result, Ok(42));
-    }
-
-    #[test]
-    fn test_sync_completion_error() {
-        let (completion, context) = SyncCompletion::<i32>::new();
-
-        // Simulate callback being called with error
-        unsafe { SyncCompletion::<i32>::complete_err(context, "test error".to_string()) };
-
-        let result = completion.wait();
-        assert_eq!(result, Err("test error".to_string()));
-    }
-
-    #[test]
-    fn test_unit_completion_callback_success() {
-        let (completion, context) = UnitCompletion::new();
-
-        // Simulate successful callback
-        UnitCompletion::callback(context, true, std::ptr::null());
-
-        let result = completion.wait();
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn test_unit_completion_callback_error() {
-        let (completion, context) = UnitCompletion::new();
-        let error_msg = std::ffi::CString::new("test error").unwrap();
-
-        // Simulate error callback
-        UnitCompletion::callback(context, false, error_msg.as_ptr());
-
-        let result = completion.wait();
-        assert_eq!(result, Err("test error".to_string()));
-    }
-
-    #[test]
-    fn test_error_from_cstr_null() {
-        let result = unsafe { error_from_cstr(std::ptr::null()) };
-        assert_eq!(result, "Unknown error");
-    }
-
-    #[test]
-    fn test_error_from_cstr_valid() {
-        let msg = std::ffi::CString::new("hello").unwrap();
-        let result = unsafe { error_from_cstr(msg.as_ptr()) };
-        assert_eq!(result, "hello");
-    }
-
-    #[test]
-    fn test_async_completion_immediate() {
-        let (future, context) = AsyncCompletion::<i32>::create();
-
-        // Complete immediately before polling
-        unsafe { AsyncCompletion::complete_ok(context, 42) };
-
-        // Poll should return Ready immediately
-        let waker = std::task::Waker::noop();
-        let mut cx = Context::from_waker(waker);
-        let mut pinned = std::pin::pin!(future);
-
-        match pinned.as_mut().poll(&mut cx) {
-            Poll::Ready(Ok(v)) => assert_eq!(v, 42),
-            _ => panic!("Expected Ready(Ok(42))"),
-        }
-    }
-}

swift-bridge/Sources/CoreGraphics/CoreGraphics.swift

@@ -158,6 +158,40 @@ public func saveCGImageToPNG(_ image: OpaquePointer, _ pathPtr: UnsafePointer<CC
     return CGImageDestinationFinalize(destination)
 }
 
+/// Save CGImage to file with specified format
+/// format: 0=PNG, 1=JPEG, 2=TIFF, 3=GIF, 4=BMP, 5=HEIC
+/// quality: 0.0-1.0 for lossy formats (JPEG, HEIC)
+@_cdecl("cgimage_save_to_file")
+public func saveCGImageToFile(_ image: OpaquePointer, _ pathPtr: UnsafePointer<CChar>, _ format: Int32, _ quality: Float) -> Bool {
+    let cgImage = Unmanaged<CGImage>.fromOpaque(UnsafeRawPointer(image)).takeUnretainedValue()
+    let path = String(cString: pathPtr)
+    let url = URL(fileURLWithPath: path)
+    
+    let utType: UTType
+    switch format {
+    case 0: utType = .png
+    case 1: utType = .jpeg
+    case 2: utType = .tiff
+    case 3: utType = .gif
+    case 4: utType = .bmp
+    case 5: utType = .heic
+    default: return false
+    }
+    
+    guard let destination = CGImageDestinationCreateWithURL(url as CFURL, utType.identifier as CFString, 1, nil) else {
+        return false
+    }
+    
+    // Set quality for lossy formats
+    var properties: [CFString: Any]? = nil
+    if format == 1 || format == 5 { // JPEG or HEIC
+        properties = [kCGImageDestinationLossyCompressionQuality: quality]
+    }
+    
+    CGImageDestinationAddImage(destination, cgImage, properties as CFDictionary?)
+    return CGImageDestinationFinalize(destination)
+}
+
 @_cdecl("cgimage_hash")
 public func cgimageHash(_ image: OpaquePointer) -> Int {
     let cgImage = Unmanaged<CGImage>.fromOpaque(UnsafeRawPointer(image)).takeUnretainedValue()

tests/audio_devices_tests.rs

@@ -0,0 +1,28 @@
+//! Tests for audio input device enumeration
+
+use screencapturekit::audio_devices::AudioInputDevice;
+
+#[test]
+fn test_list_audio_devices() {
+    // Should not panic
+    let devices = AudioInputDevice::list();
+    // On most Macs, there should be at least one built-in microphone
+    println!("Found {} audio input devices", devices.len());
+    for device in &devices {
+        println!(
+            "  {} - {} (default: {})",
+            device.id, device.name, device.is_default
+        );
+    }
+}
+
+#[test]
+fn test_default_device() {
+    // Should not panic
+    if let Some(device) = AudioInputDevice::default_device() {
+        println!("Default device: {} - {}", device.id, device.name);
+        assert!(device.is_default);
+    } else {
+        println!("No default audio input device");
+    }
+}