Struct Encoder

pub struct Encoder { /* private fields */ }

Encodes video.

Implementations

impl Encoder

pub fn builder() -> Setup

Creates a new builder with default options.

For more options see Setup::new.

Examples found in repository

examples/fade.rs (line 13)

fn main() {
    const WIDTH: usize = 480;
    const HEIGHT: usize = 360;

    // Initialize things.

    let mut encoder = Encoder::builder()
        .fps(60, 1)
        .build(Colorspace::RGB, WIDTH as _, HEIGHT as _)
        .unwrap();
    let mut file = File::create("fade.h264").unwrap();
    let mut canvas = vec![0; WIDTH * HEIGHT * 3];

    println!("Initialized!");

    // Write the headers.

    {
        let headers = encoder.headers().unwrap();
        file.write_all(headers.entirety()).unwrap();
    }

    // Queue each frame.

    for i in 0..300 {
        frame(i as f64 / 300.0, &mut canvas);
        let image = Image::rgb(WIDTH as _, HEIGHT as _, &canvas);
        let (data, _) = encoder.encode((60 * i) as _, image).unwrap();
        file.write_all(data.entirety()).unwrap();
    }

    // Finally, flush any delayed frames.

    {
        let mut flush = encoder.flush();
        while let Some(result) = flush.next() {
            let (data, _) = result.unwrap();
            file.write_all(data.entirety()).unwrap();
        }
    }

    println!("Done! The output is at `fade.h264`.");
    println!("Good luck finding a H.264 viewer, though! ;)");
}

pub fn encode( &mut self, pts: i64, image: Image<'_>, ) -> Result<(Data<'_>, Picture)>

Feeds a frame to the encoder.

Panics

Panics if there is a mismatch between the image and the encoder regarding width, height or colorspace.

Examples found in repository

examples/fade.rs (line 34)

fn main() {
    const WIDTH: usize = 480;
    const HEIGHT: usize = 360;

    // Initialize things.

    let mut encoder = Encoder::builder()
        .fps(60, 1)
        .build(Colorspace::RGB, WIDTH as _, HEIGHT as _)
        .unwrap();
    let mut file = File::create("fade.h264").unwrap();
    let mut canvas = vec![0; WIDTH * HEIGHT * 3];

    println!("Initialized!");

    // Write the headers.

    {
        let headers = encoder.headers().unwrap();
        file.write_all(headers.entirety()).unwrap();
    }

    // Queue each frame.

    for i in 0..300 {
        frame(i as f64 / 300.0, &mut canvas);
        let image = Image::rgb(WIDTH as _, HEIGHT as _, &canvas);
        let (data, _) = encoder.encode((60 * i) as _, image).unwrap();
        file.write_all(data.entirety()).unwrap();
    }

    // Finally, flush any delayed frames.

    {
        let mut flush = encoder.flush();
        while let Some(result) = flush.next() {
            let (data, _) = result.unwrap();
            file.write_all(data.entirety()).unwrap();
        }
    }

    println!("Done! The output is at `fade.h264`.");
    println!("Good luck finding a H.264 viewer, though! ;)");
}

pub unsafe fn encode_unchecked( &mut self, pts: i64, image: Image<'_>, ) -> Result<(Data<'_>, Picture)>

Feeds a frame to the encoder.

Unsafety

The caller must ensure that the width, height and colorspace of the image are the same as that of the encoder.

pub fn headers(&mut self) -> Result<Data<'_>>

Gets the video headers, which should be sent first.

Examples found in repository

examples/fade.rs (line 25)

fn main() {
    const WIDTH: usize = 480;
    const HEIGHT: usize = 360;

    // Initialize things.

    let mut encoder = Encoder::builder()
        .fps(60, 1)
        .build(Colorspace::RGB, WIDTH as _, HEIGHT as _)
        .unwrap();
    let mut file = File::create("fade.h264").unwrap();
    let mut canvas = vec![0; WIDTH * HEIGHT * 3];

    println!("Initialized!");

    // Write the headers.

    {
        let headers = encoder.headers().unwrap();
        file.write_all(headers.entirety()).unwrap();
    }

    // Queue each frame.

    for i in 0..300 {
        frame(i as f64 / 300.0, &mut canvas);
        let image = Image::rgb(WIDTH as _, HEIGHT as _, &canvas);
        let (data, _) = encoder.encode((60 * i) as _, image).unwrap();
        file.write_all(data.entirety()).unwrap();
    }

    // Finally, flush any delayed frames.

    {
        let mut flush = encoder.flush();
        while let Some(result) = flush.next() {
            let (data, _) = result.unwrap();
            file.write_all(data.entirety()).unwrap();
        }
    }

    println!("Done! The output is at `fade.h264`.");
    println!("Good luck finding a H.264 viewer, though! ;)");
}

pub fn flush(self) -> Flush

Begins flushing the encoder, to handle any delayed frames.

let mut flush = encoder.flush();

while let Some(result) = flush.next() {
    if let Ok((data, picture)) = result {
        // Handle data.
    }
}

Examples found in repository

examples/fade.rs (line 41)

fn main() {
    const WIDTH: usize = 480;
    const HEIGHT: usize = 360;

    // Initialize things.

    let mut encoder = Encoder::builder()
        .fps(60, 1)
        .build(Colorspace::RGB, WIDTH as _, HEIGHT as _)
        .unwrap();
    let mut file = File::create("fade.h264").unwrap();
    let mut canvas = vec![0; WIDTH * HEIGHT * 3];

    println!("Initialized!");

    // Write the headers.

    {
        let headers = encoder.headers().unwrap();
        file.write_all(headers.entirety()).unwrap();
    }

    // Queue each frame.

    for i in 0..300 {
        frame(i as f64 / 300.0, &mut canvas);
        let image = Image::rgb(WIDTH as _, HEIGHT as _, &canvas);
        let (data, _) = encoder.encode((60 * i) as _, image).unwrap();
        file.write_all(data.entirety()).unwrap();
    }

    // Finally, flush any delayed frames.

    {
        let mut flush = encoder.flush();
        while let Some(result) = flush.next() {
            let (data, _) = result.unwrap();
            file.write_all(data.entirety()).unwrap();
        }
    }

    println!("Done! The output is at `fade.h264`.");
    println!("Good luck finding a H.264 viewer, though! ;)");
}

pub fn width(&self) -> i32

The width required of any input images.

pub fn height(&self) -> i32

The height required of any input images.

pub fn encoding(&self) -> Encoding

The encoding required of any input images.

Trait Implementations

impl Drop for Encoder

fn drop(&mut self)

Executes the destructor for this type.