source code

libs/scrap/examples/ffplay.rs

@@ -0,0 +1,51 @@
+extern crate scrap;
+
+fn main() {
+    use scrap::{Capturer, Display};
+    use std::io::ErrorKind::WouldBlock;
+    use std::io::Write;
+    use std::process::{Command, Stdio};
+
+    let d = Display::primary().unwrap();
+    let (w, h) = (d.width(), d.height());
+
+    let child = Command::new("ffplay")
+        .args(&[
+            "-f",
+            "rawvideo",
+            "-pixel_format",
+            "bgr0",
+            "-video_size",
+            &format!("{}x{}", w, h),
+            "-framerate",
+            "60",
+            "-",
+        ])
+        .stdin(Stdio::piped())
+        .spawn()
+        .expect("This example requires ffplay.");
+
+    let mut capturer = Capturer::new(d, false).unwrap();
+    let mut out = child.stdin.unwrap();
+
+    loop {
+        match capturer.frame(0) {
+            Ok(frame) => {
+                // Write the frame, removing end-of-row padding.
+                let stride = frame.len() / h;
+                let rowlen = 4 * w;
+                for row in frame.chunks(stride) {
+                    let row = &row[..rowlen];
+                    out.write_all(row).unwrap();
+                }
+            }
+            Err(ref e) if e.kind() == WouldBlock => {
+                // Wait for the frame.
+            }
+            Err(_) => {
+                // We're done here.
+                break;
+            }
+        }
+    }
+}

libs/scrap/examples/list.rs

@@ -0,0 +1,16 @@
+extern crate scrap;
+
+use scrap::Display;
+
+fn main() {
+    let displays = Display::all().unwrap();
+
+    for (i, display) in displays.iter().enumerate() {
+        println!(
+            "Display {} [{}x{}]",
+            i + 1,
+            display.width(),
+            display.height()
+        );
+    }
+}

libs/scrap/examples/record-screen.rs

@@ -0,0 +1,161 @@
+extern crate docopt;
+extern crate quest;
+extern crate repng;
+extern crate scrap;
+extern crate serde;
+extern crate webm;
+
+use std::fs::{File, OpenOptions};
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use std::{io, thread};
+
+use docopt::Docopt;
+use webm::mux;
+use webm::mux::Track;
+
+use scrap::codec as vpx_encode;
+use scrap::{Capturer, Display, STRIDE_ALIGN};
+
+const USAGE: &'static str = "
+Simple WebM screen capture.
+
+Usage:
+  record-screen <path> [--time=<s>] [--fps=<fps>] [--bv=<kbps>] [--ba=<kbps>] [--codec CODEC]
+  record-screen (-h | --help)
+
+Options:
+  -h --help      Show this screen.
+  --time=<s>     Recording duration in seconds.
+  --fps=<fps>    Frames per second [default: 30].
+  --bv=<kbps>    Video bitrate in kilobits per second [default: 5000].
+  --ba=<kbps>    Audio bitrate in kilobits per second [default: 96].
+  --codec CODEC  Configure the codec used. [default: vp9]
+                 Valid values: vp8, vp9.
+";
+
+#[derive(Debug, serde::Deserialize)]
+struct Args {
+    arg_path: PathBuf,
+    flag_codec: Codec,
+    flag_time: Option<u64>,
+    flag_fps: u64,
+    flag_bv: u32,
+    flag_ba: u32,
+}
+
+#[derive(Debug, serde::Deserialize)]
+enum Codec {
+    Vp8,
+    Vp9,
+}
+
+fn main() -> io::Result<()> {
+    let args: Args = Docopt::new(USAGE)
+        .and_then(|d| d.deserialize())
+        .unwrap_or_else(|e| e.exit());
+
+    let duration = args.flag_time.map(Duration::from_secs);
+
+    let d = Display::primary().unwrap();
+    let (width, height) = (d.width() as u32, d.height() as u32);
+
+    // Setup the multiplexer.
+
+    let out = match {
+        OpenOptions::new()
+            .write(true)
+            .create_new(true)
+            .open(&args.arg_path)
+    } {
+        Ok(file) => file,
+        Err(ref e) if e.kind() == io::ErrorKind::AlreadyExists => {
+            if loop {
+                quest::ask("Overwrite the existing file? [y/N] ");
+                if let Some(b) = quest::yesno(false)? {
+                    break b;
+                }
+            } {
+                File::create(&args.arg_path)?
+            } else {
+                return Ok(());
+            }
+        }
+        Err(e) => return Err(e.into()),
+    };
+
+    let mut webm =
+        mux::Segment::new(mux::Writer::new(out)).expect("Could not initialize the multiplexer.");
+
+    let (vpx_codec, mux_codec) = match args.flag_codec {
+        Codec::Vp8 => (vpx_encode::VideoCodecId::VP8, mux::VideoCodecId::VP8),
+        Codec::Vp9 => (vpx_encode::VideoCodecId::VP9, mux::VideoCodecId::VP9),
+    };
+
+    let mut vt = webm.add_video_track(width, height, None, mux_codec);
+
+    // Setup the encoder.
+
+    let mut vpx = vpx_encode::Encoder::new(
+        &vpx_encode::Config {
+            width,
+            height,
+            timebase: [1, 1000],
+            bitrate: args.flag_bv,
+            codec: vpx_codec,
+            rc_min_quantizer: 0,
+            rc_max_quantizer: 0,
+            speed: 6,
+        },
+        0,
+    )
+    .unwrap();
+
+    // Start recording.
+
+    let start = Instant::now();
+    let stop = Arc::new(AtomicBool::new(false));
+
+    thread::spawn({
+        let stop = stop.clone();
+        move || {
+            let _ = quest::ask("Recording! Press ⏎ to stop.");
+            let _ = quest::text();
+            stop.store(true, Ordering::Release);
+        }
+    });
+
+    let spf = Duration::from_nanos(1_000_000_000 / args.flag_fps);
+
+    // Capturer object is expensive, avoiding to create it frequently.
+    let mut c = Capturer::new(d, true).unwrap();
+    while !stop.load(Ordering::Acquire) {
+        let now = Instant::now();
+        let time = now - start;
+
+        if Some(true) == duration.map(|d| time > d) {
+            break;
+        }
+
+        if let Ok(frame) = c.frame(0) {
+            let ms = time.as_secs() * 1000 + time.subsec_millis() as u64;
+
+            for frame in vpx.encode(ms as i64, &frame, STRIDE_ALIGN).unwrap() {
+                vt.add_frame(frame.data, frame.pts as u64 * 1_000_000, frame.key);
+            }
+        }
+
+        let dt = now.elapsed();
+        if dt < spf {
+            thread::sleep(spf - dt);
+        }
+    }
+
+    // End things.
+
+    let _ = webm.finalize(None);
+
+    Ok(())
+}

libs/scrap/examples/screenshot.rs

@@ -0,0 +1,122 @@
+extern crate repng;
+extern crate scrap;
+
+use std::fs::File;
+use std::io::ErrorKind::WouldBlock;
+use std::thread;
+use std::time::Duration;
+
+use scrap::{i420_to_rgb, Capturer, Display};
+
+fn main() {
+    let n = Display::all().unwrap().len();
+    for i in 0..n {
+        record(i);
+    }
+}
+
+fn get_display(i: usize) -> Display {
+    Display::all().unwrap().remove(i)
+}
+
+fn record(i: usize) {
+    let one_second = Duration::new(1, 0);
+    let one_frame = one_second / 60;
+
+    let display = get_display(i);
+    let mut capturer = Capturer::new(display, false).expect("Couldn't begin capture.");
+    let (w, h) = (capturer.width(), capturer.height());
+
+    loop {
+        // Wait until there's a frame.
+
+        let buffer = match capturer.frame(0) {
+            Ok(buffer) => buffer,
+            Err(error) => {
+                if error.kind() == WouldBlock {
+                    // Keep spinning.
+                    thread::sleep(one_frame);
+                    continue;
+                } else {
+                    panic!("Error: {}", error);
+                }
+            }
+        };
+
+        println!("Captured! Saving...");
+
+        // Flip the BGRA image into a RGBA image.
+
+        let mut bitflipped = Vec::with_capacity(w * h * 4);
+        let stride = buffer.len() / h;
+
+        for y in 0..h {
+            for x in 0..w {
+                let i = stride * y + 4 * x;
+                bitflipped.extend_from_slice(&[buffer[i + 2], buffer[i + 1], buffer[i], 255]);
+            }
+        }
+
+        // Save the image.
+
+        let name = format!("screenshot{}_1.png", i);
+        repng::encode(
+            File::create(name.clone()).unwrap(),
+            w as u32,
+            h as u32,
+            &bitflipped,
+        )
+        .unwrap();
+
+        println!("Image saved to `{}`.", name);
+        break;
+    }
+
+    drop(capturer);
+    let display = get_display(i);
+    let mut capturer = Capturer::new(display, true).expect("Couldn't begin capture.");
+    let (w, h) = (capturer.width(), capturer.height());
+
+    loop {
+        // Wait until there's a frame.
+
+        let buffer = match capturer.frame(0) {
+            Ok(buffer) => buffer,
+            Err(error) => {
+                if error.kind() == WouldBlock {
+                    // Keep spinning.
+                    thread::sleep(one_frame);
+                    continue;
+                } else {
+                    panic!("Error: {}", error);
+                }
+            }
+        };
+
+        println!("Captured! Saving...");
+
+        let mut frame = Default::default();
+        i420_to_rgb(w, h, &buffer, &mut frame);
+
+        let mut bitflipped = Vec::with_capacity(w * h * 4);
+        let stride = frame.len() / h;
+
+        for y in 0..h {
+            for x in 0..w {
+                let i = stride * y + 3 * x;
+                bitflipped.extend_from_slice(&[frame[i], frame[i + 1], frame[i + 2], 255]);
+            }
+        }
+        let name = format!("screenshot{}_2.png", i);
+        repng::encode(
+            File::create(name.clone()).unwrap(),
+            w as u32,
+            h as u32,
+            &bitflipped,
+        )
+        .unwrap();
+
+        println!("Image saved to `{}`.", name);
+        break;
+    }
+}