lamco-video

Video frame processing and RDP bitmap conversion for Wayland screen capture.

Features

• Frame Processing Pipeline: Configurable video frame processing with rate limiting
• RDP Bitmap Conversion: Convert PipeWire frames to RDP-ready bitmap format
• Damage Region Tracking: Optimize updates by only sending changed regions
• Buffer Pooling: Efficient memory management with reusable buffers
• Priority-Based Dispatch: Multi-stream coordination with backpressure handling
• SIMD Optimization: Automatic use of SIMD instructions where available

Quick Start

use lamco_video::{FrameProcessor, ProcessorConfig, BitmapConverter};
use lamco_pipewire::VideoFrame;
use tokio::sync::mpsc;

// Create frame processor
let config = ProcessorConfig::default();
let processor = std::sync::Arc::new(FrameProcessor::new(config, 1920, 1080));

// Create channels
let (input_tx, input_rx) = mpsc::channel(30);
let (output_tx, mut output_rx) = mpsc::channel(30);

// Start processor
let processor_clone = processor.clone();
tokio::spawn(async move {
    processor_clone.start(input_rx, output_tx).await
});

// Send frames from lamco-pipewire, receive bitmap updates
while let Some(bitmap_update) = output_rx.recv().await {
    for rect in &bitmap_update.rectangles {
        println!("Update region: {:?}", rect.rectangle);
    }
}

Configuration

Processor Configuration

use lamco_video::ProcessorConfig;

let config = ProcessorConfig {
    target_fps: 60,           // Target frame rate
    max_queue_depth: 30,      // Max frames in queue before dropping
    adaptive_quality: true,   // Enable adaptive quality
    damage_threshold: 0.05,   // Minimum damage area to process (5%)
    drop_on_full_queue: true, // Drop frames when queue is full
    enable_metrics: true,     // Enable statistics collection
};

Dispatcher Configuration

use lamco_video::DispatcherConfig;

let config = DispatcherConfig {
    channel_size: 30,          // Buffer size per stream
    priority_dispatch: true,   // Enable priority-based dispatch
    max_frame_age_ms: 150,     // Drop frames older than 150ms
    enable_backpressure: true, // Enable backpressure handling
    high_water_mark: 0.8,      // Trigger backpressure at 80%
    low_water_mark: 0.5,       // Release backpressure at 50%
    load_balancing: true,      // Enable load balancing
};

Architecture

The processing pipeline:

┌────────────────────┐
│  lamco-pipewire    │
│  (VideoFrame)      │
└─────────┬──────────┘
          │
          ▼
┌────────────────────┐
│  FrameDispatcher   │ ◄── Multi-stream routing
│  (priority queue)  │     Backpressure handling
└─────────┬──────────┘
          │
          ▼
┌────────────────────┐
│  FrameProcessor    │ ◄── Frame rate limiting
│  (rate control)    │     Age-based dropping
└─────────┬──────────┘
          │
          ▼
┌────────────────────┐
│  BitmapConverter   │ ◄── Pixel format conversion
│  (format conv)     │     Damage region tracking
└─────────┬──────────┘     Buffer pooling
          │
          ▼
┌────────────────────┐
│  BitmapUpdate      │ ◄── RDP-ready rectangles
│  (RDP output)      │
└────────────────────┘

RDP Pixel Formats

The converter supports these RDP-compatible output formats:

Feature Flags

[dependencies]
lamco-video = { version = "0.1", features = ["full"] }

Performance

Typical performance on modern hardware:

• Conversion latency: < 1ms per frame (1080p)
• Memory usage: < 50MB (with buffer pooling)
• Throughput: > 200 MB/s (with SIMD)
• Frame rates: Tested up to 144Hz

Requirements

• Linux with a Wayland compositor
• Rust 1.77+

Related Crates

• lamco-portal - XDG Desktop Portal integration
• lamco-pipewire - PipeWire screen capture

License

Licensed under either of:

• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.