Struct Capture

pub struct Capture<V: VideoEncoder + Send> {
    pub(crate) controls: Arc<CaptureControls>,
    pub(crate) worker_handles: Vec<JoinHandle<Result<()>>>,
    pub(crate) video_encoder: Option<Arc<Mutex<V>>>,
    pub(crate) pw_video_terminate_tx: Option<Sender<Terminate>>,
    pub(crate) audio_encoder: Option<Arc<Mutex<dyn AudioEncoder + Send>>>,
    pub(crate) pw_audio_terminate_tx: Option<Sender<Terminate>>,
}

Main capture instance for recording screen content and audio.

Capture provides methods to control the recording process, retrieve encoded frames, and manage the capture lifecycle.

Examples

use waycap_rs::pipeline::builder::CaptureBuilder;
use waycap_rs::types::config::{QualityPreset, VideoEncoder};

// Create a capture instance
let mut capture = CaptureBuilder::new()
    .with_quality_preset(QualityPreset::Medium)
    .with_video_encoder(VideoEncoder::H264Vaapi)
    .build()
    .expect("Failed to create capture");

// Start the capture
capture.start().expect("Failed to start capture");

// Get video receiver
let video_receiver = capture.get_video_receiver();

// Process Frames
loop {
    let frame = video_receiver.recv();
    println!("Received an encoded frame");
}

Fields

controls: Arc<CaptureControls>

worker_handles: Vec<JoinHandle<Result<()>>>

video_encoder: Option<Arc<Mutex<V>>>

pw_video_terminate_tx: Option<Sender<Terminate>>

audio_encoder: Option<Arc<Mutex<dyn AudioEncoder + Send>>>

pw_audio_terminate_tx: Option<Sender<Terminate>>

Implementations

impl<V: VideoEncoder + PipewireSPA + StartVideoEncoder> Capture<V>

pub fn new_with_encoder( video_encoder: V, include_cursor: bool, target_fps: u64, ) -> Result<Self>

where V: 'static,

pub(crate) fn start_pipewire_video( &mut self, include_cursor: bool, ) -> Result<(Receiver<RawVideoFrame>, Arc<ReadyState>, Resolution)>

pub(crate) fn start_pipewire_audio( &mut self, audio_encoder_type: AudioEncoderType, ready_state: Arc<ReadyState>, ) -> Result<Receiver<RawAudioFrame>>

impl<V: VideoEncoder> Capture<V>

pub fn start(&mut self) -> Result<()>

Enables capture streams to send their frames to their encoders

pub fn controls(&mut self) -> Arc<CaptureControls>

Temporarily stops the recording by blocking frames from being sent to the encoders

pub fn finish(&mut self) -> Result<()>

Stop recording and drain the encoders of any last frames they have in their internal buffers. These frames are discarded.

pub fn reset(&mut self) -> Result<()>

Resets the encoder states so we can resume encoding from within this same session

pub fn close(&mut self) -> Result<()>

Close the connection. Once called the struct cannot be re-used and must be re-built with the crate::pipeline::builder::CaptureBuilder to record again. If your goal is to temporarily stop recording use [Self::pause] or Self::finish + Self::reset

pub fn get_output(&mut self) -> Receiver<V::Output>

impl Capture<DynamicEncoder>

pub fn new( video_encoder_type: Option<VideoEncoderType>, audio_encoder_type: AudioEncoderType, quality: QualityPreset, include_cursor: bool, include_audio: bool, target_fps: u64, ) -> Result<Self>

pub fn get_video_receiver(&mut self) -> Receiver<EncodedVideoFrame>

Get a channel for which to receive encoded video frames.

Returns a [crossbeam::channel::Receiver] which allows multiple consumers. Each call creates a new consumer that will receive all future frames.

pub fn get_audio_receiver(&mut self) -> Result<Receiver<EncodedAudioFrame>>

Get a channel for which to receive encoded audio frames.

Returns a [crossbeam::channel::Receiver] which allows multiple consumers. Each call creates a new consumer that will receive all future frames.

pub fn with_video_encoder<F, R>(&self, f: F) -> R

where F: FnOnce(&Option<Video>) -> R,

Perform an action with the video encoder

Examples

let mut output = ffmpeg_next::format::output(&filename)?;

capture.with_video_encoder(|enc| {
    if let Some(video_encoder) = enc {
        let mut video_stream = output.add_stream(video_encoder.codec().unwrap()).unwrap();
        video_stream.set_time_base(video_encoder.time_base());
        video_stream.set_parameters(video_encoder);
    }
});
output.write_header()?;

pub fn with_audio_encoder<F, R>(&self, f: F) -> R

where F: FnOnce(&Option<Audio>) -> R,

Perform an action with the audio encoder

Examples

let mut output = ffmpeg_next::format::output(&filename)?;
capture.with_audio_encoder(|enc| {
    if let Some(audio_encoder) = enc {
        let mut audio_stream = output.add_stream(audio_encoder.codec().unwrap()).unwrap();
        audio_stream.set_time_base(audio_encoder.time_base());
        audio_stream.set_parameters(audio_encoder);

    }
});
output.write_header()?;

Trait Implementations

impl<V: VideoEncoder> Drop for Capture<V>

fn drop(&mut self)

Executes the destructor for this type.