Struct VpxEncoder 

pub struct VpxEncoder { /* private fields */ }

One libvpx session for one capture.

Implementations

impl VpxEncoder

pub fn new( settings: &RustCaptureSettings, codec: Codec, rgba: bool, ) -> Result<Self, String>

Open a VP8 or VP9 session on host frames in the byte order rgba names.

pub fn codec(&self) -> Codec

pub fn library(&self) -> &'static str

The library behind the session, as the logs name it.

pub fn is_fullcolor(&self) -> bool

Whether the session carries 4:4:4 (VP9 profile 1, or 3 at 10 bits).

pub fn bit_depth(&self) -> u32

The bits per sample the session codes: 10 in VP9 profiles 2 and 3.

pub fn is_full_range(&self) -> bool

VP9 keeps the limited range of its 4:2:0 in profile 1, so the decoder hint a client sends for it stays true; VP8 has no other.

pub fn last_reference(&self) -> Reference

The frame the last encoded frame predicted from.

pub fn invalidate_reference(&mut self, frame_id: u16) -> bool

Leave frame frame_id and every frame after it out of the predictions; the next frame predicts from an earlier buffer, or is a key frame when none is left.

pub fn acknowledge_reference(&mut self, frame_id: u16, held: bool)

Every consumer holds frame frame_id, or where not held was sent it (ReferenceSlots::acknowledge).

pub fn last_quality(&self) -> Option<u32>

The quality index the rate control last coded a frame at, held frames aside.

pub fn last_size(&self) -> Option<usize>

The bytes of the last frame the rate control coded, held frames aside, where a constant-rate cleanup runs through that rate control (holds_quantizer).

pub fn holds_quantizer(&self) -> bool

Whether the cleanup of a still screen holds a frame at its quantizer: at a constant quantizer, and at a constant rate for VP8, whose rate control leaves a still screen as it is (a screen of text at 2 Mbit/s at 1080p stayed at 33.6 dB, where the held refresh reached 42.8). VP9’s refines one, so its constant-rate cleanup runs through the rate control instead: 43.6 dB in 2.5 s with no frame over 75 kB, where the held refresh was one of 347 kB.

pub fn hold_quantizer(&mut self, crf: u32, band: Option<(f64, f64)>)

Encode the next frame at the quantizer the quality index crf selects, whatever the rate control, and put the session’s own rate control back for the frame after: the cleanup of a still screen. A held key frame of a constant-rate session starts at the quantizer the last one says fits HELD_KEY_BUDGET_S of the target (held_key_start), and one that comes out past it is coded again, as a key frame, at the coarser quantizer held_key_retry picks. band, the share of the picture from and to in raster order, confines the quantizer to the macroblocks it covers where the session holds a band (band_size), and the rest of the frame is left as the reference has it.

pub fn band_size(&self) -> Option<usize>

The bytes of the last held frame (0 before one), where the session holds a band of a frame at a quantizer: VP8, through libvpx’s region-of-interest map (band_roi), at a rate that leaves a band room in a frame. A VP8 frame codes every macroblock’s mode even where it skips them all, about a third of a bit each at 720p and 1080p, so below BAND_BITS_PER_MB of frame budget a band a frame is mostly that and the sweep cannot keep the rate: 1080p text at 0.25 Mbit/s (half a bit) ended at 29.5 dB in bands against 42.0 held whole, where 720p at 0.25 (1.2 bits) ended at 41.5 against 42.0 with the worst wait at the target 5.0 s against 18.5. The refresh is held whole below it.

pub fn reconfigure_rate( &mut self, settings: &RustCaptureSettings, ) -> Result<(), String>

Re-program the rate control when a rate or frame-rate setting changed, live.

pub fn encode_host( &mut self, pixels: &[u8], stride: usize, rgba: bool, frame_number: u64, crf: u32, force_idr: bool, ) -> Result<Vec<u8>, String>

Encode one packed host frame at the quality index crf, as a key frame when force_idr or when no reference is left to predict from.

Trait Implementations

impl Drop for VpxEncoder

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.

impl Send for VpxEncoder