Struct Encoder 

pub struct Encoder { /* private fields */ }

A Constrained Baseline H.264 encoder.

Implementations

impl Encoder

pub fn new(cfg: EncoderConfig) -> Result<Self, EncodeError>

Creates an encoder, validating that the configuration is within the implemented subset.

Examples found in repository

examples/rd_skip_speed.rs (line 63)

fn encode(frames: &[YuvFrame], w: usize, h: usize, rd_skip: bool) -> (f64, usize) {
    let mut cfg = EncoderConfig::new(w, h);
    cfg.qp = std::env::var("RS_QP").ok().and_then(|v| v.parse().ok()).unwrap_or(27);
    cfg.gop_size = 30;
    cfg.tune_rd_skip = rd_skip;
    cfg.tune_rd_skip_fast_t = std::env::var("RS_GATE").ok().and_then(|v| v.parse().ok());
    let mut enc = Encoder::new(cfg).expect("encoder");
    let t = std::time::Instant::now();
    let mut bytes = 0usize;
    for fr in frames {
        bytes += enc.encode(fr).len();
    }
    (t.elapsed().as_secs_f64(), bytes)
}

examples/bit_accountant.rs (line 57)

fn main() {
    let path = std::env::args().nth(1).unwrap_or_else(|| "video-tests/clips/foreman_cif.y4m".into());
    let n: usize = std::env::var("BA_FRAMES").ok().and_then(|v| v.parse().ok()).unwrap_or(24);
    let qp: u8 = std::env::var("BA_QP").ok().and_then(|v| v.parse().ok()).unwrap_or(27);
    let (w, h, frames) = read_y4m(&path, n);
    let name = std::path::Path::new(&path).file_stem().unwrap().to_string_lossy().to_string();
    for (pname, preset) in [("quality", Preset::Quality)] {
        let mut cfg = EncoderConfig::new(w, h);
        cfg.qp = qp;
        cfg.gop_size = 60;
        cfg.preset = preset;
        rusty_h264_encoder::bitacct::reset();
        rusty_h264_encoder::bitacct::set_enabled(true);
        let mut enc = Encoder::new(cfg).unwrap();
        let mut total = 0usize;
        for f in &frames {
            total += enc.encode(f).len();
        }
        rusty_h264_encoder::bitacct::add_actual_bytes(total);
        rusty_h264_encoder::bitacct::set_enabled(false);
        let mbs = (w.div_ceil(16) * h.div_ceil(16) * frames.len()) as u64;
        rusty_h264_encoder::bitacct::dump(
            &format!("{name} {pname} qp{qp} x{} ({} bytes)", frames.len(), total),
            mbs,
        );
        if std::env::var_os("BA_MVDTAB").is_some() {
            rusty_h264_encoder::bitacct::dump_mvd_table();
        }
    }
}

examples/thread_bench.rs (line 42)

fn main() {
    let path = std::env::args().nth(1).unwrap();
    let n: usize = std::env::var("TB_FRAMES").ok().and_then(|v| v.parse().ok()).unwrap_or(240);
    let gop: u32 = std::env::var("TB_GOP").ok().and_then(|v| v.parse().ok()).unwrap_or(30);
    let (w, h, frames) = read_y4m(&path, n);
    for (pn, preset) in [("balanced", Preset::Balanced), ("quality", Preset::Quality)] {
        let mut cfg = EncoderConfig::new(w, h);
        cfg.qp = 27; cfg.gop_size = gop; cfg.preset = preset;
        // best-of-3 each arm
        let mut seq_ms = f64::MAX; let mut seq_out = Vec::new();
        for _ in 0..3 {
            let mut enc = Encoder::new(cfg.clone()).unwrap();
            let t = std::time::Instant::now();
            let mut o = Vec::new();
            for f in &frames { o.extend_from_slice(&enc.encode(f)); }
            seq_ms = seq_ms.min(t.elapsed().as_secs_f64() * 1e3);
            seq_out = o;
        }
        let mut par_ms = f64::MAX; let mut par_out = Vec::new();
        for _ in 0..3 {
            let enc = Encoder::new(cfg.clone()).unwrap();
            let t = std::time::Instant::now();
            let o: Vec<u8> = enc.encode_all(&frames).unwrap().concat();
            par_ms = par_ms.min(t.elapsed().as_secs_f64() * 1e3);
            par_out = o;
        }
        assert_eq!(seq_out, par_out, "seq != parallel — compression WOULD be compromised");
        println!("{pn:<9} x{} gop{gop}: seq {seq_ms:.0} ms  parallel {par_ms:.0} ms  speedup {:.2}x  (byte-identical ✓)", frames.len(), seq_ms / par_ms);
    }
}

examples/me_snap_ab.rs (line 42)

fn main() {
    let a: Vec<String> = std::env::args().skip(1).collect();
    let (w, h) = a[1].split_once('x').unwrap();
    let (w, h): (usize, usize) = (w.parse().unwrap(), h.parse().unwrap());
    let frames = load(&a[0], w, h, std::env::var("RS_FRAMES").ok().and_then(|v| v.parse().ok()).unwrap_or(60));
    let preset = match std::env::var("RS_PRESET").unwrap_or_default().as_str() {
        "fast" => Preset::Fast, "quality" => Preset::Quality, _ => Preset::Balanced,
    };
    let arm_off: u32 = std::env::var("RS_ARM_OFF").ok().and_then(|v| v.parse().ok()).unwrap_or(0);
    let arm_on: u32 = std::env::var("RS_ARM_ON").ok().and_then(|v| v.parse().ok()).unwrap_or(3);
    let run = |on: bool| {
        let m = if on { arm_on } else { arm_off };
        let mut cfg = EncoderConfig::new(w, h);
        cfg.qp = std::env::var("RS_QP").ok().and_then(|v| v.parse().ok()).unwrap_or(27);
        cfg.gop_size = 30;
        cfg.preset = preset;
        cfg.tune_me_snap = m & 1 != 0;
        cfg.tune_me_subpel_iter = m & 2 != 0;
        let mut enc = Encoder::new(cfg).expect("enc");
        let t = std::time::Instant::now();
        let mut b = 0usize;
        for f in &frames { b += enc.encode(f).len(); }
        (t.elapsed().as_secs_f64(), b)
    };
    let mut best = [f64::MAX; 2];
    let mut bytes = [0usize; 2];
    for pass in 0..10 {
        let arm = pass % 2;
        let (t, b) = run(arm == 1);
        if t < best[arm] { best[arm] = t; }
        bytes[arm] = b;
    }
    let px = (w * h * frames.len()) as f64;
    println!("arm {arm_off} -> {arm_on} — {} {w}x{h} {} frames {preset:?}", a[0], frames.len());
    println!("  off : {:>7.1} ms  {:>6.2} Mpx/s  {:>9} bytes", best[0]*1e3, px/best[0]/1e6, bytes[0]);
    println!("  on  : {:>7.1} ms  {:>6.2} Mpx/s  {:>9} bytes", best[1]*1e3, px/best[1]/1e6, bytes[1]);
    println!("  speed {:>6.3}x   size {:>+6.2}%", best[0]/best[1],
             100.0*(bytes[1] as f64/bytes[0] as f64 - 1.0));
}

examples/mbtree_bench.rs (line 81)

fn main() {
    let path = std::env::args().nth(1).expect("usage: mbtree_bench <clip.y4m>");
    let env = |k: &str, d: usize| -> usize {
        std::env::var(k).ok().and_then(|v| v.parse().ok()).unwrap_or(d)
    };
    let (n, qp, gop, reps) = (env("MB_FRAMES", 48), env("MB_QP", 27), env("MB_GOP", 30), env("MB_REPS", 3));
    if let Ok(la) = std::env::var("MB_LA") {
        std::env::set_var("RFF_MBTREE_LA", la);
    }
    let (w, h, frames) = read_y4m(&path, n);
    println!("mbtree_bench {}x{} x{} qp{qp} gop{gop} (best-of-{reps})", w, h, frames.len());

    let mut off_ms = f64::MAX;
    let mut on_ms = f64::MAX;
    let (mut off_h, mut on_h, mut off_b, mut on_b) = (0u64, 0u64, 0usize, 0usize);
    let mut calls = 0u64;
    // Alternate the arms so thermal drift hits both equally.
    for _ in 0..reps {
        for on in [false, true] {
            let mut cfg = EncoderConfig::new(w, h);
            cfg.qp = qp as u8;
            cfg.gop_size = gop as u32;
            cfg.preset = Preset::Quality;
            cfg.mbtree = on;
            let enc = Encoder::new(cfg).expect("cfg");
            rusty_h264_encoder::mbtree_satd_reset();
            let t = std::time::Instant::now();
            let out: Vec<u8> = enc.encode_all(&frames).expect("encode").concat();
            let ms = t.elapsed().as_secs_f64() * 1e3;
            if on {
                on_ms = on_ms.min(ms);
                on_h = fnv1a(&out);
                on_b = out.len();
                calls = rusty_h264_encoder::mbtree_satd_calls();
            } else {
                off_ms = off_ms.min(ms);
                off_h = fnv1a(&out);
                off_b = out.len();
            }
        }
    }
    println!("  mbtree OFF: {off_ms:8.1} ms  {off_b:>8} bytes  hash {off_h:016x}");
    println!("  mbtree ON : {on_ms:8.1} ms  {on_b:>8} bytes  hash {on_h:016x}");
    println!(
        "  lookahead work: {calls} candidate evals ({:.0}/MB/frame, DETERMINISTIC)",
        calls as f64 / ((w / 16 * (h / 16)) as f64 * frames.len() as f64)
    );
    println!(
        "  lookahead overhead: {:+.1}%   size {:+.2}%",
        100.0 * (on_ms / off_ms - 1.0),
        100.0 * (on_b as f64 / off_b as f64 - 1.0)
    );
}

examples/me_oracle.rs (line 47)

fn main() {
    let a: Vec<String> = std::env::args().skip(1).collect();
    let (w, h) = a[1].split_once('x').unwrap();
    let (w, h): (usize, usize) = (w.parse().unwrap(), h.parse().unwrap());
    let nf: usize = std::env::var("RS_FRAMES").ok().and_then(|v| v.parse().ok()).unwrap_or(20);
    let frames = load(&a[0], w, h, nf);

    let preset = match std::env::var("RS_PRESET").unwrap_or_default().as_str() {
        "fast" => Preset::Fast,
        "quality" => Preset::Quality,
        _ => Preset::Balanced,
    };
    let mut cfg = EncoderConfig::new(w, h);
    cfg.qp = std::env::var("RS_QP").ok().and_then(|v| v.parse().ok()).unwrap_or(27);
    cfg.gop_size = 30;
    cfg.preset = preset;
    let mut enc = Encoder::new(cfg).expect("encoder");
    for f in &frames {
        let _ = enc.encode(f);
    }

    let p: Vec<u64> = rusty_h264_encoder::ME_PROBE
        .iter()
        .map(|c| c.load(std::sync::atomic::Ordering::Relaxed))
        .collect();
    let (n, ours, oracle, worse, evals) = (p[0].max(1), p[1], p[2], p[3], p[4]);
    let (oracle_sp, worse_sp) = (p[5], p[6]);
    println!("ME oracle — {} ({w}x{h}, {} frames, {preset:?})\n", a[0], frames.len());
    println!("  searches                {n}");
    println!("  mean cost   ours        {:>10.1}", ours as f64 / n as f64);
    println!("  mean cost   exhaustive  {:>10.1}", oracle as f64 / n as f64);
    println!("  ---> we are {:>6.2}% above the achievable minimum",
             100.0 * (ours as f64 - oracle as f64) / oracle as f64);
    println!("  searches the oracle beat {:>9} ({:.1}%)", worse, 100.0 * worse as f64 / n as f64);
    // the oracle's own 49x49 grid + 8 sub-pel probes are included in `evals`
    println!("
  + exhaustive SUB-PEL (all quarter-pel in +-3):");
    println!("  mean cost   exhaustive  {:>10.1}", oracle_sp as f64 / n as f64);
    println!("  ---> we are {:>6.2}% above the achievable minimum",
             100.0 * (ours as f64 - oracle_sp as f64) / oracle_sp as f64);
    println!("  searches it beat        {:>9} ({:.1}%)", worse_sp, 100.0 * worse_sp as f64 / n as f64);
    let oracle_evals = 0;
    println!("\n  cost() evals/search     {:>8.1}  (ours, oracle's {oracle_evals} excluded)",
             evals as f64 / n as f64 - oracle_evals as f64);
}

pub fn config(&self) -> &EncoderConfig

The active configuration.

pub fn encode(&mut self, frame: &YuvFrame) -> Vec<u8>

Encodes one frame, returning the Annex-B access unit. Every gop_size frames (and always the first) is coded as an IDR, prefixed with SPS/PPS.

Generation 1 codes every picture as an IDR (all-intra); inter frames arrive with motion compensation later.

Examples found in repository

examples/rd_skip_speed.rs (line 67)

fn encode(frames: &[YuvFrame], w: usize, h: usize, rd_skip: bool) -> (f64, usize) {
    let mut cfg = EncoderConfig::new(w, h);
    cfg.qp = std::env::var("RS_QP").ok().and_then(|v| v.parse().ok()).unwrap_or(27);
    cfg.gop_size = 30;
    cfg.tune_rd_skip = rd_skip;
    cfg.tune_rd_skip_fast_t = std::env::var("RS_GATE").ok().and_then(|v| v.parse().ok());
    let mut enc = Encoder::new(cfg).expect("encoder");
    let t = std::time::Instant::now();
    let mut bytes = 0usize;
    for fr in frames {
        bytes += enc.encode(fr).len();
    }
    (t.elapsed().as_secs_f64(), bytes)
}

examples/bit_accountant.rs (line 60)

fn main() {
    let path = std::env::args().nth(1).unwrap_or_else(|| "video-tests/clips/foreman_cif.y4m".into());
    let n: usize = std::env::var("BA_FRAMES").ok().and_then(|v| v.parse().ok()).unwrap_or(24);
    let qp: u8 = std::env::var("BA_QP").ok().and_then(|v| v.parse().ok()).unwrap_or(27);
    let (w, h, frames) = read_y4m(&path, n);
    let name = std::path::Path::new(&path).file_stem().unwrap().to_string_lossy().to_string();
    for (pname, preset) in [("quality", Preset::Quality)] {
        let mut cfg = EncoderConfig::new(w, h);
        cfg.qp = qp;
        cfg.gop_size = 60;
        cfg.preset = preset;
        rusty_h264_encoder::bitacct::reset();
        rusty_h264_encoder::bitacct::set_enabled(true);
        let mut enc = Encoder::new(cfg).unwrap();
        let mut total = 0usize;
        for f in &frames {
            total += enc.encode(f).len();
        }
        rusty_h264_encoder::bitacct::add_actual_bytes(total);
        rusty_h264_encoder::bitacct::set_enabled(false);
        let mbs = (w.div_ceil(16) * h.div_ceil(16) * frames.len()) as u64;
        rusty_h264_encoder::bitacct::dump(
            &format!("{name} {pname} qp{qp} x{} ({} bytes)", frames.len(), total),
            mbs,
        );
        if std::env::var_os("BA_MVDTAB").is_some() {
            rusty_h264_encoder::bitacct::dump_mvd_table();
        }
    }
}

examples/thread_bench.rs (line 45)

fn main() {
    let path = std::env::args().nth(1).unwrap();
    let n: usize = std::env::var("TB_FRAMES").ok().and_then(|v| v.parse().ok()).unwrap_or(240);
    let gop: u32 = std::env::var("TB_GOP").ok().and_then(|v| v.parse().ok()).unwrap_or(30);
    let (w, h, frames) = read_y4m(&path, n);
    for (pn, preset) in [("balanced", Preset::Balanced), ("quality", Preset::Quality)] {
        let mut cfg = EncoderConfig::new(w, h);
        cfg.qp = 27; cfg.gop_size = gop; cfg.preset = preset;
        // best-of-3 each arm
        let mut seq_ms = f64::MAX; let mut seq_out = Vec::new();
        for _ in 0..3 {
            let mut enc = Encoder::new(cfg.clone()).unwrap();
            let t = std::time::Instant::now();
            let mut o = Vec::new();
            for f in &frames { o.extend_from_slice(&enc.encode(f)); }
            seq_ms = seq_ms.min(t.elapsed().as_secs_f64() * 1e3);
            seq_out = o;
        }
        let mut par_ms = f64::MAX; let mut par_out = Vec::new();
        for _ in 0..3 {
            let enc = Encoder::new(cfg.clone()).unwrap();
            let t = std::time::Instant::now();
            let o: Vec<u8> = enc.encode_all(&frames).unwrap().concat();
            par_ms = par_ms.min(t.elapsed().as_secs_f64() * 1e3);
            par_out = o;
        }
        assert_eq!(seq_out, par_out, "seq != parallel — compression WOULD be compromised");
        println!("{pn:<9} x{} gop{gop}: seq {seq_ms:.0} ms  parallel {par_ms:.0} ms  speedup {:.2}x  (byte-identical ✓)", frames.len(), seq_ms / par_ms);
    }
}

examples/me_snap_ab.rs (line 45)

fn main() {
    let a: Vec<String> = std::env::args().skip(1).collect();
    let (w, h) = a[1].split_once('x').unwrap();
    let (w, h): (usize, usize) = (w.parse().unwrap(), h.parse().unwrap());
    let frames = load(&a[0], w, h, std::env::var("RS_FRAMES").ok().and_then(|v| v.parse().ok()).unwrap_or(60));
    let preset = match std::env::var("RS_PRESET").unwrap_or_default().as_str() {
        "fast" => Preset::Fast, "quality" => Preset::Quality, _ => Preset::Balanced,
    };
    let arm_off: u32 = std::env::var("RS_ARM_OFF").ok().and_then(|v| v.parse().ok()).unwrap_or(0);
    let arm_on: u32 = std::env::var("RS_ARM_ON").ok().and_then(|v| v.parse().ok()).unwrap_or(3);
    let run = |on: bool| {
        let m = if on { arm_on } else { arm_off };
        let mut cfg = EncoderConfig::new(w, h);
        cfg.qp = std::env::var("RS_QP").ok().and_then(|v| v.parse().ok()).unwrap_or(27);
        cfg.gop_size = 30;
        cfg.preset = preset;
        cfg.tune_me_snap = m & 1 != 0;
        cfg.tune_me_subpel_iter = m & 2 != 0;
        let mut enc = Encoder::new(cfg).expect("enc");
        let t = std::time::Instant::now();
        let mut b = 0usize;
        for f in &frames { b += enc.encode(f).len(); }
        (t.elapsed().as_secs_f64(), b)
    };
    let mut best = [f64::MAX; 2];
    let mut bytes = [0usize; 2];
    for pass in 0..10 {
        let arm = pass % 2;
        let (t, b) = run(arm == 1);
        if t < best[arm] { best[arm] = t; }
        bytes[arm] = b;
    }
    let px = (w * h * frames.len()) as f64;
    println!("arm {arm_off} -> {arm_on} — {} {w}x{h} {} frames {preset:?}", a[0], frames.len());
    println!("  off : {:>7.1} ms  {:>6.2} Mpx/s  {:>9} bytes", best[0]*1e3, px/best[0]/1e6, bytes[0]);
    println!("  on  : {:>7.1} ms  {:>6.2} Mpx/s  {:>9} bytes", best[1]*1e3, px/best[1]/1e6, bytes[1]);
    println!("  speed {:>6.3}x   size {:>+6.2}%", best[0]/best[1],
             100.0*(bytes[1] as f64/bytes[0] as f64 - 1.0));
}

examples/me_oracle.rs (line 49)

fn main() {
    let a: Vec<String> = std::env::args().skip(1).collect();
    let (w, h) = a[1].split_once('x').unwrap();
    let (w, h): (usize, usize) = (w.parse().unwrap(), h.parse().unwrap());
    let nf: usize = std::env::var("RS_FRAMES").ok().and_then(|v| v.parse().ok()).unwrap_or(20);
    let frames = load(&a[0], w, h, nf);

    let preset = match std::env::var("RS_PRESET").unwrap_or_default().as_str() {
        "fast" => Preset::Fast,
        "quality" => Preset::Quality,
        _ => Preset::Balanced,
    };
    let mut cfg = EncoderConfig::new(w, h);
    cfg.qp = std::env::var("RS_QP").ok().and_then(|v| v.parse().ok()).unwrap_or(27);
    cfg.gop_size = 30;
    cfg.preset = preset;
    let mut enc = Encoder::new(cfg).expect("encoder");
    for f in &frames {
        let _ = enc.encode(f);
    }

    let p: Vec<u64> = rusty_h264_encoder::ME_PROBE
        .iter()
        .map(|c| c.load(std::sync::atomic::Ordering::Relaxed))
        .collect();
    let (n, ours, oracle, worse, evals) = (p[0].max(1), p[1], p[2], p[3], p[4]);
    let (oracle_sp, worse_sp) = (p[5], p[6]);
    println!("ME oracle — {} ({w}x{h}, {} frames, {preset:?})\n", a[0], frames.len());
    println!("  searches                {n}");
    println!("  mean cost   ours        {:>10.1}", ours as f64 / n as f64);
    println!("  mean cost   exhaustive  {:>10.1}", oracle as f64 / n as f64);
    println!("  ---> we are {:>6.2}% above the achievable minimum",
             100.0 * (ours as f64 - oracle as f64) / oracle as f64);
    println!("  searches the oracle beat {:>9} ({:.1}%)", worse, 100.0 * worse as f64 / n as f64);
    // the oracle's own 49x49 grid + 8 sub-pel probes are included in `evals`
    println!("
  + exhaustive SUB-PEL (all quarter-pel in +-3):");
    println!("  mean cost   exhaustive  {:>10.1}", oracle_sp as f64 / n as f64);
    println!("  ---> we are {:>6.2}% above the achievable minimum",
             100.0 * (ours as f64 - oracle_sp as f64) / oracle_sp as f64);
    println!("  searches it beat        {:>9} ({:.1}%)", worse_sp, 100.0 * worse_sp as f64 / n as f64);
    let oracle_evals = 0;
    println!("\n  cost() evals/search     {:>8.1}  (ours, oracle's {oracle_evals} excluded)",
             evals as f64 / n as f64 - oracle_evals as f64);
}

pub fn try_encode(&mut self, frame: &YuvFrame) -> Result<Vec<u8>, EncodeError>

Fallible encode.

With a lookahead feature active (currently mb-tree, on by default in the constant-QP path) this BUFFERS: mb-tree needs a whole GOP of future frames before it can assign any of their QPs, so the returned Vec is empty while the GOP fills and then carries that entire GOP’s access units at once. The concatenation of every return value plus flush is exactly what encode_all produces — byte for byte.

You must call flush at end of stream or the final partial GOP is never emitted. (A debug build asserts if the encoder is dropped with frames still buffered.) For zero added latency set cfg.mbtree = false, which restores one-AU-per-call behaviour.

pub fn flush(&mut self) -> Vec<u8>

Emits any frames still held by the lookahead queue (end of stream).

Returns the trailing access units, or empty when nothing is buffered — so it is always safe to call, including when no lookahead feature is active.

pub fn try_flush(&mut self) -> Result<Vec<u8>, EncodeError>

Fallible flush.

pub fn encode_all( &self, frames: &[YuvFrame], ) -> Result<Vec<Vec<u8>>, EncodeError>

Batch-encodes every frame, returning one Annex-B access unit per frame.

At constant QP the GOPs are independent — each begins with an IDR that resets the DPB, frame_num and POC, and SPS/PPS precede every IDR — so they are encoded in parallel across CPU cores and the result is byte-identical to calling encode frame-by-frame. With rate control enabled the per-frame QP depends on history, so this falls back to sequential encoding. Within a GOP, P-frames are inherently sequential (each predicts from the previous reconstruction); the parallelism is across GOPs, so it scales with the number of GOPs in the clip.

Examples found in repository

examples/thread_bench.rs (line 53)

fn main() {
    let path = std::env::args().nth(1).unwrap();
    let n: usize = std::env::var("TB_FRAMES").ok().and_then(|v| v.parse().ok()).unwrap_or(240);
    let gop: u32 = std::env::var("TB_GOP").ok().and_then(|v| v.parse().ok()).unwrap_or(30);
    let (w, h, frames) = read_y4m(&path, n);
    for (pn, preset) in [("balanced", Preset::Balanced), ("quality", Preset::Quality)] {
        let mut cfg = EncoderConfig::new(w, h);
        cfg.qp = 27; cfg.gop_size = gop; cfg.preset = preset;
        // best-of-3 each arm
        let mut seq_ms = f64::MAX; let mut seq_out = Vec::new();
        for _ in 0..3 {
            let mut enc = Encoder::new(cfg.clone()).unwrap();
            let t = std::time::Instant::now();
            let mut o = Vec::new();
            for f in &frames { o.extend_from_slice(&enc.encode(f)); }
            seq_ms = seq_ms.min(t.elapsed().as_secs_f64() * 1e3);
            seq_out = o;
        }
        let mut par_ms = f64::MAX; let mut par_out = Vec::new();
        for _ in 0..3 {
            let enc = Encoder::new(cfg.clone()).unwrap();
            let t = std::time::Instant::now();
            let o: Vec<u8> = enc.encode_all(&frames).unwrap().concat();
            par_ms = par_ms.min(t.elapsed().as_secs_f64() * 1e3);
            par_out = o;
        }
        assert_eq!(seq_out, par_out, "seq != parallel — compression WOULD be compromised");
        println!("{pn:<9} x{} gop{gop}: seq {seq_ms:.0} ms  parallel {par_ms:.0} ms  speedup {:.2}x  (byte-identical ✓)", frames.len(), seq_ms / par_ms);
    }
}

examples/mbtree_bench.rs (line 84)

fn main() {
    let path = std::env::args().nth(1).expect("usage: mbtree_bench <clip.y4m>");
    let env = |k: &str, d: usize| -> usize {
        std::env::var(k).ok().and_then(|v| v.parse().ok()).unwrap_or(d)
    };
    let (n, qp, gop, reps) = (env("MB_FRAMES", 48), env("MB_QP", 27), env("MB_GOP", 30), env("MB_REPS", 3));
    if let Ok(la) = std::env::var("MB_LA") {
        std::env::set_var("RFF_MBTREE_LA", la);
    }
    let (w, h, frames) = read_y4m(&path, n);
    println!("mbtree_bench {}x{} x{} qp{qp} gop{gop} (best-of-{reps})", w, h, frames.len());

    let mut off_ms = f64::MAX;
    let mut on_ms = f64::MAX;
    let (mut off_h, mut on_h, mut off_b, mut on_b) = (0u64, 0u64, 0usize, 0usize);
    let mut calls = 0u64;
    // Alternate the arms so thermal drift hits both equally.
    for _ in 0..reps {
        for on in [false, true] {
            let mut cfg = EncoderConfig::new(w, h);
            cfg.qp = qp as u8;
            cfg.gop_size = gop as u32;
            cfg.preset = Preset::Quality;
            cfg.mbtree = on;
            let enc = Encoder::new(cfg).expect("cfg");
            rusty_h264_encoder::mbtree_satd_reset();
            let t = std::time::Instant::now();
            let out: Vec<u8> = enc.encode_all(&frames).expect("encode").concat();
            let ms = t.elapsed().as_secs_f64() * 1e3;
            if on {
                on_ms = on_ms.min(ms);
                on_h = fnv1a(&out);
                on_b = out.len();
                calls = rusty_h264_encoder::mbtree_satd_calls();
            } else {
                off_ms = off_ms.min(ms);
                off_h = fnv1a(&out);
                off_b = out.len();
            }
        }
    }
    println!("  mbtree OFF: {off_ms:8.1} ms  {off_b:>8} bytes  hash {off_h:016x}");
    println!("  mbtree ON : {on_ms:8.1} ms  {on_b:>8} bytes  hash {on_h:016x}");
    println!(
        "  lookahead work: {calls} candidate evals ({:.0}/MB/frame, DETERMINISTIC)",
        calls as f64 / ((w / 16 * (h / 16)) as f64 * frames.len() as f64)
    );
    println!(
        "  lookahead overhead: {:+.1}%   size {:+.2}%",
        100.0 * (on_ms / off_ms - 1.0),
        100.0 * (on_b as f64 / off_b as f64 - 1.0)
    );
}

Trait Implementations

impl Debug for Encoder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for Encoder

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.