ScreenCaptureKit-rs

https://doom-fish.github.io/screencapturekit-rs
Admin
ScreenCaptureKit-rs provides safe, idiomatic Rust bindings for Apple’s ScreenCaptureKit framework,...
Tokens:1,394,925
Snippets:10,641
Trust Score:8.3
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Start capturing with SCStream

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/lib.rs.html

Sets up and starts screen capture: gets shareable content, creates a filter for the first display, configures a 1920x1080 BGRA stream with cursor, adds a handler, and starts capture. The example sleeps for 5 seconds to keep the stream alive.

```rust
use screencapturekit::prelude::*;

# struct MyHandler;
# impl SCStreamOutputTrait for MyHandler {
#     fn did_output_sample_buffer(&self, _: CMSampleBuffer, _: SCStreamOutputType) {}
# }
# fn main() -> Result<(), Box<dyn std::error::Error>> {
// Get available displays
let content = SCShareableContent::get()?;
let display = content.displays().into_iter().next().ok_or("No display")?;

// Configure what to capture
let filter = SCContentFilter::create()
    .with_display(&display)
    .with_excluding_windows(&[])
    .build()?;

// Configure how to capture
let config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080)
    .with_pixel_format(PixelFormat::BGRA)
    .with_shows_cursor(true);

// Create stream and add handler
let mut stream = SCStream::new(&filter, &config)?;
stream.add_output_handler(MyHandler, SCStreamOutputType::Screen)?;

// Start capturing
stream.start_capture()?;

// ... capture runs in background ...
std::thread::sleep(std::time::Duration::from_secs(5));
```

--------------------------------

### Example: default_from_system() usage

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/content_sharing_picker/struct.SCContentSharingPickerConfiguration.html

Shows how to start from the system defaults and then override only what you need. The example calls default_from_system() and then sets excluded bundle IDs. It expects the configuration to be read successfully and the bundle IDs to have no NUL byte.

```rust
use screencapturekit::content_sharing_picker::*;

// Start from the system defaults, then override only what you need.
let mut config = SCContentSharingPickerConfiguration::default_from_system()
    .expect("read the default picker configuration");
config.set_excluded_bundle_ids(&["com.apple.dock"]).expect("bundle IDs have no NUL byte");
```

--------------------------------

### Example: Creating RecordingCallbacks with Closures

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/recording_output/struct.RecordingCallbacks.html?search=

Example showing how to create a RecordingCallbacks delegate with closures for start, finish, and fail events, and use it with SCRecordingOutput. Includes creating a configuration with an output URL and handling specific events.

```rust
use screencapturekit::recording_output::{
    SCRecordingOutput, SCRecordingOutputConfiguration, RecordingCallbacks
};
use std::path::Path;

let config = SCRecordingOutputConfiguration::new().expect("create recording configuration")
    .with_output_url(Path::new("/tmp/recording.mp4")).expect("output path is valid UTF-8 without NUL bytes");

// Create delegate with all callbacks
let delegate = RecordingCallbacks::new()
    .on_start(|| println!("Recording started!"))
    .on_finish(|| println!("Recording finished!"))
    .on_fail(|error| eprintln!("Recording failed: {}", error));

let recording = SCRecordingOutput::new_with_delegate(&config, delegate);

// Or just handle specific events
let delegate = RecordingCallbacks::new()
    .on_fail(|error| eprintln!("Error: {}", error));
```

--------------------------------

### Create and start an SCStream with filter and configuration

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/stream/sc_stream.rs.html?search=

Shows how to create an SCStream using SCShareableContent, SCContentFilter, and SCStreamConfiguration, then start and stop capture. The example is marked no_run and returns Result<(), Box<dyn Error>>.

```rust
use screencapturekit::prelude::*;

# fn example() -> Result<(), Box<dyn std::error::Error>> {
// Get shareable content
let content = SCShareableContent::get()?;
let display = &content.displays()[0];

// Create filter and configuration
let filter = SCContentFilter::create()
    .with_display(display)
    .with_excluding_windows(&[])
    .build()?;
let config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080);

// Create and start stream
let mut stream = SCStream::new(&filter, &config)?;
stream.start_capture()?;

// ... capture frames ...

stream.stop_capture()?;
# Ok(())
# }
```
```

--------------------------------

### SCStream capture workflow example

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/stream/mod.rs.html?search=

Example from the module documentation showing the core workflow: create a content filter, configure the stream, create an SCStream, register an output handler, and start capture. The hidden lines (prefixed with #) are Rust doctest setup and error handling; the example is marked no_run.

```rust
use screencapturekit::prelude::*;

# let content = SCShareableContent::get().unwrap();
# let display = &content.displays()[0];
let filter = SCContentFilter::create()
    .with_display(display)
    .with_excluding_windows(&[])
    .build()?;
let config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080);

let mut stream = SCStream::new(&filter, &config)?;
stream.add_output_handler(
    |sample, output_type| println!("Got frame!"),
    SCStreamOutputType::Screen
).expect("register output handler");
stream.start_capture()?;
# Ok::<(), screencapturekit::error::SCError>(())
```

--------------------------------

### Create and start an SCStream

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/stream/sc_stream/struct.SCStream.html

Shows the full workflow: get shareable content, create a filter and configuration, create the stream, start capture, and stop capture.

```rust
use screencapturekit::prelude::*;

// Get shareable content
let content = SCShareableContent::get()?;
let display = &content.displays()[0];

// Create filter and configuration
let filter = SCContentFilter::create()
    .with_display(display)
    .with_excluding_windows(&[])
    .build()?;
let config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080);

// Create and start stream
let mut stream = SCStream::new(&filter, &config)?;
stream.start_capture()?;

// ... capture frames ...

stream.stop_capture()?;
```

--------------------------------

### Get picked windows and create custom filter

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/content_sharing_picker/struct.SCPickerResult.html

Example for the windows() method. Shows how to retrieve the picked windows and create a custom SCContentFilter using the first window.

```rust
use screencapturekit::content_sharing_picker::*;
use screencapturekit::prelude::*;

let config = SCContentSharingPickerConfiguration::new().expect("create picker configuration");
SCContentSharingPicker::show(&config, |outcome| {
    if let SCPickerOutcome::Picked(result) = outcome {
        let windows = result.windows();
        if let Some(window) = windows.first() {
            // Create custom filter with a picked window
            let filter = SCContentFilter::create()
                .with_window(window)
                .build().expect("failed to build content filter");
        }
    }
});
```

--------------------------------

### SCStream capture workflow example

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/stream/index.html?search=std%3A%3Avec

Shows the typical workflow for setting up a screen capture stream: create a content filter, configure the stream, create the stream, add an output handler, and start capture. Uses the screencapturekit prelude and requires a display object.

```rust
use screencapturekit::prelude::*;

let filter = SCContentFilter::create()
    .with_display(display)
    .with_excluding_windows(&[])
    .build()?;
let config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080);

let mut stream = SCStream::new(&filter, &config)?;
stream.add_output_handler(
    |sample, output_type| println!("Got frame!"),
    SCStreamOutputType::Screen
).expect("register output handler");
stream.start_capture()?;
```

--------------------------------

### Get picked displays and create custom filter

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/content_sharing_picker/struct.SCPickerResult.html

Example for the displays() method. Shows how to retrieve the picked displays and create a custom SCContentFilter using the first display, excluding all windows.

```rust
use screencapturekit::content_sharing_picker::*;
use screencapturekit::prelude::*;

let config = SCContentSharingPickerConfiguration::new().expect("create picker configuration");
SCContentSharingPicker::show(&config, |outcome| {
    if let SCPickerOutcome::Picked(result) = outcome {
        let displays = result.displays();
        if let Some(display) = displays.first() {
            // Create custom filter with the picked display
            let filter = SCContentFilter::create()
                .with_display(display)
                .with_excluding_windows(&[])
                .build().expect("failed to build content filter");
        }
    }
});
```

--------------------------------

### SCStreamConfiguration::from_preset with doc example

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/stream/configuration/mod.rs.html?search=

Shows the from_preset constructor and its usage example from the documentation comments.

```rust
/// Create a configuration from a preset (macOS 15.0+)
///
/// Presets provide optimized default values for specific use cases,
/// particularly for HDR capture.
///
/// # Examples
///
/// ```no_run
/// use screencapturekit::stream::configuration::{SCStreamConfiguration, SCStreamConfigurationPreset};
///
/// let config = SCStreamConfiguration::from_preset(SCStreamConfigurationPreset::CaptureHDRStreamLocalDisplay)
///     .expect("macOS 15.0 or later");
/// ```
#[cfg(feature = "macos_15_0")]
#[allow(clippy::missing_errors_doc)]
pub fn from_preset(preset: SCStreamConfigurationPreset) -> crate::error::SCResult<Self> {
    let ptr = unsafe { crate::ffi::sc_stream_configuration_create_with_preset(preset as i32) };
    if ptr.is_null() {
        #[cfg(feature = "macos_26_0")]
        let required_version = match preset {
            SCStreamConfigurationPreset::CaptureHDRRecordingPreservedSDRHDR10 => "26.0",
            _ => "15.0",
        };
        #[cfg(not(feature = "macos_26_0"))]
        let required_version = "15.0";
```

--------------------------------

### CGSize::new example

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/cg/struct.CGSize.html?search=

Example showing how to create a CGSize with the new constructor.

```rust
use apple_cf::cg::CGSize;

let size = CGSize::new(800.0, 600.0);
assert_eq!(size.width, 800.0);
```

--------------------------------

### SCStreamConfiguration::new with doc example

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/stream/configuration/mod.rs.html?search=

Shows the new() constructor and its usage example from the documentation comments.

```rust
/// Create a new stream configuration with default values
///
/// This is equivalent to `SCStreamConfiguration::default()`.
///
/// # Examples
///
/// ```
/// use screencapturekit::prelude::*;
///
/// let config = SCStreamConfiguration::new()
///     .with_width(1920)
///     .with_height(1080);
/// ```
#[must_use]
pub fn new() -> Self {
    Self::default()
}
```

--------------------------------

### SCStream full capture lifecycle example

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/stream/sc_stream.rs.html

Shows the full lifecycle of an SCStream: get shareable content, create a filter and configuration, start capture, and stop capture. The example is marked no_run and wraps the body in a function returning Result.

```rust
use screencapturekit::prelude::*;

# fn example() -> Result<(), Box<dyn std::error::Error>> {
// Get shareable content
let content = SCShareableContent::get()?;
let display = &content.displays()[0];

// Create filter and configuration
let filter = SCContentFilter::create()
    .with_display(display)
    .with_excluding_windows(&[])
    .build()?;
let config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080);

// Create and start stream
let mut stream = SCStream::new(&filter, &config)?;
stream.start_capture()?;

// ... capture frames ...

stream.stop_capture()?;
# Ok(())
# }
```

--------------------------------

### Basic screen capture with SCStream

Source: https://doom-fish.github.io/screencapturekit-rs/index.html

Minimal screen capture example: lists shareable content, builds a content filter, configures the stream, adds an output handler, and starts capture. Output/delegate handlers must be Send + Sync. Requires permission; run with `cargo run --example 01_basic_capture`.

```rust
use screencapturekit::prelude::*;

struct Handler;
impl SCStreamOutputTrait for Handler {
    fn did_output_sample_buffer(&self, sample: CMSampleBuffer, _: SCStreamOutputType) {
        println!("📹 frame @ {:?}", sample.presentation_timestamp());
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let content = SCShareableContent::get()?;
    let display = &content.displays()[0];

    let filter = SCContentFilter::create()
        .with_display(display)
        .with_excluding_windows(&[])
        .build()?;

    let config = SCStreamConfiguration::new()
        .with_width(1920)
        .with_height(1080)
        .with_pixel_format(PixelFormat::BGRA);

    let mut stream = SCStream::new(&filter, &config)?;
    stream.add_output_handler(Handler, SCStreamOutputType::Screen)?;
    stream.start_capture()?;

    std::thread::sleep(std::time::Duration::from_secs(5));
    stream.stop_capture()?;
    Ok(())
}
```

--------------------------------

### as_u32 example

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/struct.FourCharCode.html

Example of getting the u32 representation of a FourCharCode.

```rust
use doom_fish_utils::FourCharCode;

let code = FourCharCode::from_bytes(*b"BGRA");
let value: u32 = code.as_u32();
assert_eq!(value, 0x42475241);
```

--------------------------------

### CGSize example: create and use size

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/cg/struct.CGSize.html?search=

Example showing how to create a CGSize and use its aspect_ratio and area methods.

```rust
use apple_cf::cg::CGSize;

let size = CGSize::new(1920.0, 1080.0);
assert_eq!(size.aspect_ratio(), 1920.0 / 1080.0);
assert_eq!(size.area(), 1920.0 * 1080.0);
```

--------------------------------

### Run example programs with cargo

Source: https://doom-fish.github.io/screencapturekit-rs/index.html

Commands to run three example programs. The first runs the basic capture example. The second requires the macos_15_0 feature. The third requires the async and macos_14_0 features.

```bash
cargo run --example 01_basic_capture
cargo run --example 10_recording_output --features macos_15_0
cargo run --example 08_async            --features "async,macos_14_0"
```

--------------------------------

### Example: Create CGPoint with new

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/cg/struct.CGPoint.html?search=std%3A%3Avec

Example showing how to create a CGPoint using the new constructor and access its x field.

```rust
use apple_cf::cg::CGPoint;

let point = CGPoint::new(100.0, 200.0);
assert_eq!(point.x, 100.0);
```

--------------------------------

### CGSize::zero example

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/cg/struct.CGSize.html?search=

Example showing how to create a zero-sized CGSize and check if it is null.

```rust
use apple_cf::cg::CGSize;

let size = CGSize::zero();
assert!(size.is_null());
```

--------------------------------

### Example: Create CGPoint at origin with zero

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/cg/struct.CGPoint.html?search=std%3A%3Avec

Example showing how to create a CGPoint at the origin using the zero constructor and check if it is zero.

```rust
use apple_cf::cg::CGPoint;

let point = CGPoint::zero();
assert!(point.is_zero());
```

--------------------------------

### Example: Create CGPoint and calculate distance

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/cg/struct.CGPoint.html?search=std%3A%3Avec

Example showing how to create two CGPoint instances and calculate the distance between them using the distance_to method.

```rust
use apple_cf::cg::CGPoint;

let p1 = CGPoint::new(0.0, 0.0);
let p2 = CGPoint::new(3.0, 4.0);
assert_eq!(p1.distance_to(&p2), 5.0);
```

--------------------------------

### Start capturing a display

Source: https://doom-fish.github.io/screencapturekit-rs/index.html

Start capturing the first available display. Creates a content filter and stream configuration, adds a handler, starts capture, sleeps for 5 seconds, then stops.

```rust
use screencapturekit::prelude::*;

// Get available displays
let content = SCShareableContent::get()?;
let display = content.displays().into_iter().next().ok_or("No display")?;

// Configure what to capture
let filter = SCContentFilter::create()
    .with_display(&display)
    .with_excluding_windows(&[])
    .build()?;

// Configure how to capture
let config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080)
    .with_pixel_format(PixelFormat::BGRA)
    .with_shows_cursor(true);

// Create stream and add handler
let mut stream = SCStream::new(&filter, &config)?;
stream.add_output_handler(MyHandler, SCStreamOutputType::Screen)?;

// Start capturing
stream.start_capture()?;

// ... capture runs in background ...
std::thread::sleep(std::time::Duration::from_secs(5));

stream.stop_capture()?;
```

--------------------------------

### CGRect::new example

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/cg/struct.CGRect.html

Example of creating a CGRect with new and checking its properties.

```rust
use apple_cf::cg::CGRect;

let rect = CGRect::new(10.0, 20.0, 100.0, 200.0);
assert_eq!(rect.origin.x, 10.0);
assert_eq!(rect.size.width, 100.0);
assert_eq!(rect.max_x(), 110.0);
```

--------------------------------

### from_bytes example

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/struct.FourCharCode.html

Example of creating a FourCharCode from exactly 4 bytes and checking its display.

```rust
use doom_fish_utils::FourCharCode;

let code = FourCharCode::from_bytes(*b"BGRA");
assert_eq!(code.display(), "BGRA");
```

--------------------------------

### Start and stop screen capture

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/lib.rs.html?search=

Start capturing a display with a configured stream, run for 5 seconds, then stop.

```rust
use screencapturekit::prelude::*;

# struct MyHandler;
# impl SCStreamOutputTrait for MyHandler {
#     fn did_output_sample_buffer(&self, _: CMSampleBuffer, _: SCStreamOutputType) {}
# }
# fn main() -> Result<(), Box<dyn std::error::Error>> {
// Get available displays
let content = SCShareableContent::get()?;
let display = content.displays().into_iter().next().ok_or("No display")?;

// Configure what to capture
let filter = SCContentFilter::create()
    .with_display(&display)
    .with_excluding_windows(&[])
    .build()?;

// Configure how to capture
let config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080)
    .with_pixel_format(PixelFormat::BGRA)
    .with_shows_cursor(true);

// Create stream and add handler
let mut stream = SCStream::new(&filter, &config)?;
stream.add_output_handler(MyHandler, SCStreamOutputType::Screen)?;

// Start capturing
stream.start_capture()?;

// ... capture runs in background ...
std::thread::sleep(std::time::Duration::from_secs(5));

stream.stop_capture()?;
# Ok(())
```

--------------------------------

### Get default audio input device

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/audio_devices/struct.AudioInputDevice.html?search=std%3A%3Avec

Example of using AudioInputDevice::default_device() to get the default microphone and print its name.

```rust
use screencapturekit::audio_devices::AudioInputDevice;

if let Some(device) = AudioInputDevice::default_device() {
    println!("Default microphone: {}", device.name);
}
```

--------------------------------

### AsyncSCStream frame iteration example

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/async_api.rs.html

Example usage of `AsyncSCStream` to capture the first display, create a stream with a 1920x1080 configuration, start capture, and iterate frames asynchronously. The example is marked `no_run` and uses `?` for error handling.

```rust
# async fn example() -> Result<(), Box<dyn std::error::Error>> {
use screencapturekit::async_api::{AsyncSCShareableContent, AsyncSCStream};
use screencapturekit::stream::configuration::SCStreamConfiguration;
use screencapturekit::stream::content_filter::SCContentFilter;
use screencapturekit::stream::output_type::SCStreamOutputType;

let content = AsyncSCShareableContent::get().await?;
let display = &content.displays()[0];
let filter = SCContentFilter::create().with_display(display).with_excluding_windows(&[]).build()?;
let config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080);

let stream = AsyncSCStream::new(&filter, &config, 30, SCStreamOutputType::Screen)?;
stream.start_capture().await?;

// Process frames asynchronously
while let Some(frame) = stream.next().await {
    println!("Got frame!");
}
# Ok(())
# }
```

--------------------------------

### Result::as_mut example

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/utils/error/type.SCResult.html

Shows `Result::as_mut` to get mutable references to the contained `Ok` or `Err` values, allowing in-place mutation. The example defines a helper function that modifies the result and then verifies the changes.

```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

--------------------------------

### Prelude module documentation with feature flags and example

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/lib.rs.html?search=std%3A%3Avec

Documentation comment for the prelude module listing feature flags and showing a no_run Rust example that imports the prelude and SCScreenshotManager under the macos_14_0 feature.

```rust
/// | `macos_15_0` | `screencapturekit::recording_output` |
/// | `async` | `screencapturekit::async_api` |
///
/// Example:
/// ```rust,no_run
/// # #[cfg(feature = "macos_14_0")]
/// use screencapturekit::prelude::*;
/// # #[cfg(feature = "macos_14_0")]
/// use screencapturekit::screenshot_manager::SCScreenshotManager;
/// ```
```

--------------------------------

### AsyncSCStream usage example

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/async_api/struct.AsyncSCStream.html?search=

Example usage of AsyncSCStream: creates a stream from a display content filter and configuration, starts capture, and iterates frames asynchronously. The stream is lossy by design; when the bounded internal queue is full, the oldest sample is dropped.

```rust
use screencapturekit::async_api::{AsyncSCShareableContent, AsyncSCStream};
use screencapturekit::stream::configuration::SCStreamConfiguration;
use screencapturekit::stream::content_filter::SCContentFilter;
use screencapturekit::stream::output_type::SCStreamOutputType;

let content = AsyncSCShareableContent::get().await?;
let display = &content.displays()[0];
let filter = SCContentFilter::create().with_display(display).with_excluding_windows(&[]).build()?;
let config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080);

let stream = AsyncSCStream::new(&filter, &config, 30, SCStreamOutputType::Screen)?;
stream.start_capture().await?;

// Process frames asynchronously
while let Some(frame) = stream.next().await {
    println!("Got frame!");
}
```

--------------------------------

### List devices with default index

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/audio_devices/struct.AudioInputDevice.html?search=std%3A%3Avec

Example of using AudioInputDevice::list_with_default() to get the device list and the index of the default device in a single pass.

```rust
use screencapturekit::audio_devices::AudioInputDevice;

let (devices, default_index) = AudioInputDevice::list_with_default();
if let Some(default) = default_index.and_then(|i| devices.get(i)) {
    println!("Default: {}", default.name);
}
```

--------------------------------

### AsyncSCStream struct and async frame iteration example

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/async_api/struct.AsyncSCStream.html

Shows the struct definition and a complete example of creating an AsyncSCStream, starting capture, and iterating frames asynchronously. The stream is executor-agnostic and uses a bounded, lossy queue; use the synchronous SCStream for lossless capture.

```rust
pub struct AsyncSCStream { /* private fields */ }
```

```rust
use screencapturekit::async_api::{AsyncSCShareableContent, AsyncSCStream};
use screencapturekit::stream::configuration::SCStreamConfiguration;
use screencapturekit::stream::content_filter::SCContentFilter;
use screencapturekit::stream::output_type::SCStreamOutputType;

let content = AsyncSCShareableContent::get().await?;
let display = &content.displays()[0];
let filter = SCContentFilter::create().with_display(display).with_excluding_windows(&[]).build()?;
let config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080);

let stream = AsyncSCStream::new(&filter, &config, 30, SCStreamOutputType::Screen)?;
stream.start_capture().await?;

// Process frames asynchronously
while let Some(frame) = stream.next().await {
    println!("Got frame!");
}
```

--------------------------------

### metal::setup_metal_view

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/all.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Sets up a Metal view for rendering captured content.

```APIDOC
## metal::setup_metal_view

### Description
Sets up a Metal view for rendering captured content.

### Method
metal::setup_metal_view

### Parameters
- **view** (view handle) - Required - The Metal view to set up.

### Return Value
A result indicating success or failure.

```

--------------------------------

### Get display resolution of first display

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/shareable_content/display.rs.html

Example from the height method documentation. Retrieves shareable content and prints the width and height of the first display.

```rust
# use screencapturekit::shareable_content::SCShareableContent;
# fn example() -> Result<(), Box<dyn std::error::Error>> {
let content = SCShareableContent::get()?;
if let Some(display) = content.displays().first() {
    println!("Display resolution: {}x{}", display.width(), display.height());
}
# Ok(())
# }

```

--------------------------------

### Get display ID of first display

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/shareable_content/display.rs.html

Example from the display_id method documentation. Retrieves shareable content and prints the display ID of the first display.

```rust
# use screencapturekit::shareable_content::SCShareableContent;
# fn example() -> Result<(), Box<dyn std::error::Error>> {
let content = SCShareableContent::get()?;
if let Some(display) = content.displays().first() {
    println!("Display ID: {}", display.display_id());
}
# Ok(())
# }

```

--------------------------------

### Create SCContentFilter using prelude imports

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/stream/content_filter.rs.html

Shows how to create a content filter using the screencapturekit::prelude::* import. The example is marked no_run and demonstrates the builder pattern with with_display and with_excluding_windows.

```rust
use screencapturekit::prelude::*;

# fn example() -> Result<(), Box<dyn std::error::Error>> {
let content = SCShareableContent::get()?;
let display = &content.displays()[0];

let filter = SCContentFilter::create()
    .with_display(display)
    .with_excluding_windows(&[])
    .build()?;
# Ok(())
# }
```

--------------------------------

### Create error from SCStreamErrorCode with message

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/utils/error/enum.SCError.html?search=

Creates an error from an SCStreamErrorCode with an additional message. The example uses SCStreamErrorCode::FailedToStart and verifies the error string contains 'Failed to start'.

```rust
use screencapturekit::error::{SCError, SCStreamErrorCode};

let err = SCError::from_stream_error_code_with_message(
    SCStreamErrorCode::FailedToStart,
    "No available displays"
);
assert!(err.to_string().contains("Failed to start"));
```

--------------------------------

### setup_metal_view

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/metal/fn.setup_metal_view.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Sets up an NSView for Metal rendering by enabling layer-backed mode and assigning a Metal layer.

```APIDOC
## setup_metal_view

### Description
Sets up an `NSView` for Metal rendering by setting `wantsLayer = YES` and assigning the Metal layer to the view.

### Function Signature
```rust
pub unsafe fn setup_metal_view(view: *mut c_void, layer: &MetalLayer)
```

### Parameters
- **view** (`*mut c_void`) - Required - A pointer to a valid `NSView` object.
- **layer** (`&MetalLayer`) - Required - A reference to the Metal layer to assign to the view.

### Safety
- The `view` pointer must be a valid `NSView` pointer.

### Example
```rust
use screencapturekit::metal::{setup_metal_view, MetalLayer};
use std::ffi::c_void;

fn example(ns_view: *mut c_void) {
    let layer = MetalLayer::new();
    unsafe { setup_metal_view(ns_view, &layer); }
}
```
```

--------------------------------

### Recording Output Functions

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/all.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Functions to create, control, and query recording output objects, including starting recording, getting recorded duration and file size, and waiting for termination.

```APIDOC
## Recording Output Functions

### Description
These functions manage recording output objects, allowing creation, availability checks, and retrieval of recording statistics.

### Functions

#### ffi::sc_recording_output_create
Creates a new recording output.

#### ffi::sc_recording_output_create_with_delegate
Creates a recording output with a delegate.

#### ffi::sc_recording_output_get_recorded_duration
Returns the recorded duration.

#### ffi::sc_recording_output_get_recorded_file_size
Returns the recorded file size.

#### ffi::sc_recording_output_is_available
Returns whether the recording output is available.

#### ffi::sc_recording_output_release
Releases the recording output object.

#### ffi::sc_recording_output_retain
Retains the recording output object.

#### ffi::sc_recording_output_wait_until_terminal
Waits until the recording output reaches a terminal state.

```

--------------------------------

### Iterate windows and print titles and IDs

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/shareable_content/window/struct.SCWindow.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example usage of SCShareableContent to get all windows and print each window's title and ID. Uses the `?` operator, so it must be called from a function that returns a Result.

```rust
use screencapturekit::shareable_content::SCShareableContent;

let content = SCShareableContent::get()?;
for window in content.windows() {
    if let Some(title) = window.title() {
        println!("Window: {} (ID: {})", title, window.window_id());
    }
}
```

--------------------------------

### Get current process shareable content

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/async_api/struct.AsyncSCShareableContent.html

Example usage of AsyncSCShareableContent::current_process() to retrieve content capturable without TCC authorization. The method returns a future that resolves to content with a windows() method.

```rust
use screencapturekit::async_api::AsyncSCShareableContent;

// Get content capturable without TCC authorization
let content = AsyncSCShareableContent::current_process().await?;
println!("Found {} windows for current process", content.windows().len());
```

--------------------------------

### Create a DispatchQueue and use with SCStream

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/dispatch_queue/struct.DispatchQueue.html?search=

Example from the new method documentation showing how to create a queue and use it with SCStream's add_output_handler_with_queue.

```rust
use apple_cf::dispatch_queue::{DispatchQueue, DispatchQoS};

let queue = DispatchQueue::new("com.myapp.capture", DispatchQoS::UserInteractive);
// Use the queue with SCStream's add_output_handler_with_queue
```

--------------------------------

### SCStreamConfiguration::new and from_preset methods

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/stream/configuration/mod.rs.html?search=std%3A%3Avec

Provides constructors for SCStreamConfiguration: new() creates a default configuration, and from_preset() creates a configuration from a preset, returning an error if the required macOS version is not available.

```rust
impl SCStreamConfiguration {
    /// Create a new stream configuration with default values
    ///
    /// This is equivalent to `SCStreamConfiguration::default()`.
    ///
    /// # Examples
    ///
    /// ```
    /// use screencapturekit::prelude::*;
    ///
    /// let config = SCStreamConfiguration::new()
    ///     .with_width(1920)
    ///     .with_height(1080);
    /// ```
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Create a configuration from a preset (macOS 15.0+)
    ///
    /// Presets provide optimized default values for specific use cases,
    /// particularly for HDR capture.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use screencapturekit::stream::configuration::{SCStreamConfiguration, SCStreamConfigurationPreset};
    ///
    /// let config = SCStreamConfiguration::from_preset(SCStreamConfigurationPreset::CaptureHDRStreamLocalDisplay)
    ///     .expect("macOS 15.0 or later");
    /// ```
    #[cfg(feature = "macos_15_0")]
    #[allow(clippy::missing_errors_doc)]
    pub fn from_preset(preset: SCStreamConfigurationPreset) -> crate::error::SCResult<Self> {
        let ptr = unsafe { crate::ffi::sc_stream_configuration_create_with_preset(preset as i32) };
        if ptr.is_null() {
            #[cfg(feature = "macos_26_0")]
            let required_version = match preset {
                SCStreamConfigurationPreset::CaptureHDRRecordingPreservedSDRHDR10 => "26.0",
                _ => "15.0",
            };
            #[cfg(not(feature = "macos_26_0"))]
            let required_version = "15.0";
```

--------------------------------

### Create an ErrorHandler delegate from a closure

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/stream/delegate_trait.rs.html?search=

Shows how to use `ErrorHandler` to create a delegate from a closure that only handles errors. The example is wrapped in a function that returns a `Result` and includes setup for `SCShareableContent`, `SCContentFilter`, and `SCStreamConfiguration`.

```rust
use screencapturekit::prelude::*;
use screencapturekit::stream::delegate_trait::ErrorHandler;

# fn example() -> Result<(), Box<dyn std::error::Error>> {
# let content = SCShareableContent::get()?;
# let display = &content.displays()[0];

```

--------------------------------

### Get picked displays from SCPickerResult

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/content_sharing_picker.rs.html?search=u32+-%3E+bool

Shows how to retrieve the displays selected by the user from an SCPickerResult and create a custom SCContentFilter using the first display. The example uses SCContentSharingPicker::show with a callback that matches on SCPickerOutcome::Picked.

```rust
use screencapturekit::content_sharing_picker::*;
use screencapturekit::prelude::*;

let config = SCContentSharingPickerConfiguration::new().expect("create picker configuration");
SCContentSharingPicker::show(&config, |outcome| {
    if let SCPickerOutcome::Picked(result) = outcome {
        let displays = result.displays();
        if let Some(display) = displays.first() {
            // Create custom filter with a picked display
            let filter = SCContentFilter::create()
                .with_display(display)
                .build().expect("failed to build content filter");
        }
    }
});
```

--------------------------------

### SCStream full capture lifecycle

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/stream/sc_stream.rs.html?search=std%3A%3Avec

Shows the full lifecycle of an SCStream: get shareable content, create a filter and configuration, start capture, and stop capture. The stream is mutable because start_capture and stop_capture take &mut self.

```rust
use screencapturekit::prelude::*;

# fn example() -> Result<(), Box<dyn std::error::Error>> {
// Get shareable content
let content = SCShareableContent::get()?;
let display = &content.displays()[0];

// Create filter and configuration
let filter = SCContentFilter::create()
    .with_display(display)
    .with_excluding_windows(&[])
    .build()?;
let config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080);

// Create and start stream
let mut stream = SCStream::new(&filter, &config)?;
stream.start_capture()?;

// ... capture frames ...

stream.stop_capture()?;
# Ok(())
# }

```

--------------------------------

### CMSampleTimingInfo usage example

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/cm/struct.CMSampleTimingInfo.html?search=std%3A%3Avec

Shows how to create a CMSampleTimingInfo using new() and with_times(), and verify validity with is_valid(). The example uses apple_cf::cm types and demonstrates that new() returns an invalid timing info.

```rust
use apple_cf::cm::{CMSampleTimingInfo, CMTime};

let timing = CMSampleTimingInfo::new();
assert!(!timing.is_valid());

let duration = CMTime::new(1, 30);
let pts = CMTime::new(100, 30);
let dts = CMTime::new(100, 30);
let timing = CMSampleTimingInfo::with_times(duration, pts, dts);
assert!(timing.is_valid());
```

--------------------------------

### Create and start SCStream with delegate

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/stream/sc_stream.rs.html?search=std%3A%3Avec

Initializes a screen capture stream with a custom delegate and starts capture. The filter and configuration are created beforehand; the delegate must implement SCStreamDelegateTrait. Returns an error on failure.

```rust
/// let stream = SCStream::new_with_delegate(&filter, &config, delegate)?;
/// stream.start_capture()?;
```

--------------------------------

### Recording (macOS 15.0+): SCRecordingOutput

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/lib.rs.html?search=

Record directly to a video file. Requires macOS 15.0+. The example configures an H.264 MP4 recording output, starts a stream, records for 10 seconds, and checks recording stats.

```rust
use screencapturekit::prelude::*;
use screencapturekit::recording_output::{
    SCRecordingOutput, SCRecordingOutputConfiguration,
    SCRecordingOutputCodec, SCRecordingOutputFileType
};
use std::path::PathBuf;

let content = SCShareableContent::get()?;
let display = &content.displays()[0];

let filter = SCContentFilter::create()
    .with_display(display)
    .with_excluding_windows(&[])
    .build()?;

let stream_config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080);

// Configure recording output
let output_path = PathBuf::from("/tmp/screen_recording.mp4");
let recording_config = SCRecordingOutputConfiguration::new()?
    .with_output_url(&output_path)?
    .with_video_codec(SCRecordingOutputCodec::H264)
    .with_output_file_type(SCRecordingOutputFileType::MP4);

let recording_output = SCRecordingOutput::new(&recording_config)
    .ok_or("Failed to create recording output")?;

// Start stream and add recording
let stream = SCStream::new(&filter, &stream_config)?;
stream.add_recording_output(&recording_output)?;
stream.start_capture()?;

// Record for 10 seconds
std::thread::sleep(std::time::Duration::from_secs(10));

// Check recording stats
let duration = recording_output.recorded_duration();
let file_size = recording_output.recorded_file_size();
println!("Recorded {}/{}, {} bytes", duration.value, duration.timescale, file_size);

stream.remove_recording_output(&recording_output)?;
stream.stop_capture()?;
```

--------------------------------

### List all audio input devices

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/audio_devices/struct.AudioInputDevice.html?search=std%3A%3Avec

Example of using AudioInputDevice::list() to iterate over all devices and print their details.

```rust
use screencapturekit::audio_devices::AudioInputDevice;

let devices = AudioInputDevice::list();
for device in &devices {
    println!("{}: {} {}", device.id, device.name,
        if device.is_default { "(default)" } else { "" });
}
```

--------------------------------

### Implement SCRecordingOutputDelegate with a struct

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/recording_output/trait.SCRecordingOutputDelegate.html?search=

Shows how to implement the SCRecordingOutputDelegate trait for a custom struct. The example defines MyRecordingDelegate and implements all three methods, printing messages on start, failure, and finish. Use this when you need a custom delegate type.

```rust
use screencapturekit::recording_output::SCRecordingOutputDelegate;

struct MyRecordingDelegate;

impl SCRecordingOutputDelegate for MyRecordingDelegate {
    fn recording_did_start(&self) {
        println!("Recording started!");
    }
    fn recording_did_fail(&self, error: String) {
        eprintln!("Recording failed: {}", error);
    }
    fn recording_did_finish(&self) {
        println!("Recording finished!");
    }
}
```

--------------------------------

### pub fn data_is_ready(&self) -> bool

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/prelude/struct.CMSampleBuffer.html?search=u32+-%3E+bool

Returns whether the sample buffer's data is ready for consumption.

```APIDOC
## [Rust] CMSampleBuffer::data_is_ready

### Description
Returns whether the sample buffer's data is ready for consumption.

### Method
`pub fn data_is_ready(&self) -> bool`

### Parameters
- **self** (`&self`) - Required - The sample buffer.

### Returns
- **bool** - `true` if data is ready, `false` otherwise.
```

--------------------------------

### Create a delegate from closures with StreamCallbacks

Source: https://doom-fish.github.io/screencapturekit-rs/src/screencapturekit/stream/delegate_trait.rs.html?search=

Shows how to build a delegate from closures using `StreamCallbacks::new()` with `on_stop` and `on_error` handlers, then pass it to `SCStream::new_with_delegate`. The example is wrapped in a function that returns a `Result` and includes setup for `SCShareableContent`, `SCContentFilter`, and `SCStreamConfiguration`.

```rust
use screencapturekit::prelude::*;
use screencapturekit::stream::delegate_trait::StreamCallbacks;

# fn example() -> Result<(), Box<dyn std::error::Error>> {
# let content = SCShareableContent::get()?;
# let display = &content.displays()[0];
# let filter = SCContentFilter::create().with_display(display).with_excluding_windows(&[]).build()?;
# let config = SCStreamConfiguration::default();

let delegate = StreamCallbacks::new()
    .on_stop(|error| {
        if let Some(e) = error {
            eprintln!("Stream stopped with error: {}", e);
        }
    })
    .on_error(|error| eprintln!("Error: {}", error));

let stream = SCStream::new_with_delegate(&filter, &config, delegate)?;
# Ok(())
# }

```

--------------------------------

### Example usage of ffi_string_from_buffer

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/utils/ffi_string/fn.ffi_string_from_buffer.html?search=std%3A%3Avec

Example demonstrating how to call `ffi_string_from_buffer` with a closure that simulates an FFI call writing "hello" to the buffer. The function returns `Some("hello".to_string())` on success.

```rust
use doom_fish_utils::ffi_string::ffi_string_from_buffer;

let result = unsafe {
    ffi_string_from_buffer(64, |buf, len| {
        // Simulate FFI call that writes "hello" to buffer
        let src = b"hello\0";
        if len >= src.len() as isize {
            std::ptr::copy_nonoverlapping(src.as_ptr(), buf as *mut u8, src.len());
            true
        } else {
            false
        }
    })
};
assert_eq!(result, Some("hello".to_string()));

```

--------------------------------

### Capture and save screenshot with SCScreenshotManager

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/screenshot_manager/index.html?search=u32+-%3E+bool

Use SCScreenshotManager for a single screenshot without stream setup. The example captures the first display, creates a content filter and configuration, captures a CGImage, prints its dimensions, and saves it as PNG or JPEG with quality.

```rust
use screencapturekit::screenshot_manager::{CGImageExt, ImageFormat, SCScreenshotManager};
use screencapturekit::stream::{content_filter::SCContentFilter, configuration::SCStreamConfiguration};
use screencapturekit::shareable_content::SCShareableContent;

let content = SCShareableContent::get()?;
let display = &content.displays()[0];
let filter = SCContentFilter::create().with_display(display).with_excluding_windows(&[]).build()?;
let config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080);

// Capture as CGImage
let image = SCScreenshotManager::capture_image(&filter, &config)?;
println!("Screenshot: {}x{}", image.width(), image.height());

// Save to file
image.save_png("screenshot.png")?;

// Or save as JPEG with quality
image.save("screenshot.jpg", ImageFormat::Jpeg(0.85))?;
```

--------------------------------

### SCScreenshotConfiguration::new

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/screenshot_manager/struct.SCScreenshotConfiguration.html

Creates a new SCScreenshotConfiguration instance. Returns a Result, as shown in the example with .expect().

```APIDOC
## SCScreenshotConfiguration::new

### Description
Creates a new screenshot configuration instance. This is the entry point for configuring advanced screenshot capture.

### Method
`SCScreenshotConfiguration::new()`

### Parameters
None.

### Returns
- `Result<SCScreenshotConfiguration, Error>` - A new configuration instance on success, or an error on failure.

### Example
```rust
use screencapturekit::screenshot_manager::{SCScreenshotConfiguration, SCScreenshotDynamicRange};

let config = SCScreenshotConfiguration::new().expect("create screenshot configuration")
    .with_width(1920)
    .with_height(1080)
    .with_shows_cursor(true)
    .with_dynamic_range(SCScreenshotDynamicRange::BothSDRAndHDR);
```
```

--------------------------------

### Set up SCRecordingOutput with HEVC codec

Source: https://doom-fish.github.io/screencapturekit-rs/screencapturekit/recording_output/index.html

Configures a recording output to write to /tmp/recording.mp4 using HEVC codec, adds it to an SCStream, and starts capture. Requires macOS 15.0+ and the `macos_15_0` feature flag. The example shows creating a display filter and stream configuration, then adding the recording output to the stream.

```rust
use screencapturekit::recording_output::{
    SCRecordingOutput, SCRecordingOutputConfiguration, SCRecordingOutputCodec
};
use screencapturekit::prelude::*;
use std::path::Path;

let content = SCShareableContent::get()?;
let display = &content.displays()[0];
let filter = SCContentFilter::create().with_display(display).with_excluding_windows(&[]).build()?;
let config = SCStreamConfiguration::new()
    .with_width(1920)
    .with_height(1080);

// Configure recording output
let rec_config = SCRecordingOutputConfiguration::new()?
    .with_output_url(Path::new("/tmp/recording.mp4"))?
    .with_video_codec(SCRecordingOutputCodec::HEVC);

let recording = SCRecordingOutput::new(&rec_config).ok_or("Failed to create recording")?;

// Add to stream and start
let mut stream = SCStream::new(&filter, &config)?;
stream.add_recording_output(&recording)?;
stream.start_capture()?;

// ... record for desired duration ...

stream.stop_capture()?;
stream.remove_recording_output(&recording)?;

```
Tokens:
Raw