Struct HevcEncoder 

pub struct HevcEncoder {

    backend: Backend,
    planes: Planes,
    threads: i32,
    quality: Quality,
    rate: RateSettings,
    omit_headers: bool,
    fresh: bool,
    next_pts: u64,
    pending: Pending,
    held: Option<u32>,
    refinement: Option<Refinement>,
    offsets: Vec<f32>,
    constant: Vec<u8>,
    last_quality: Option<u32>,
    last_bytes: Option<usize>,
}

One software HEVC session for one capture.

Fields

backend: Backend

planes: Planes

threads: i32

quality: Quality

rate: RateSettings

omit_headers: bool

fresh: bool

Whether the next frame is the first after an open, which the encoder codes as a key frame on its own.

next_pts: u64

pending: Pending

held: Option<u32>

The quantizer the next frame is held at whatever the rate control (hold_quantizer).

refinement: Option<Refinement>

The blocks the next frame of the rate control’s refines (refine_blocks), and the quantizer offset of each 16x16 block of every frame, 0 where it refines nothing.

offsets: Vec<f32>

constant: Vec<u8>

The 16x16 blocks of the next frame that held still and are clean, one byte each in raster order, nonzero where constant (constant_blocks); empty where none is.

last_quality: Option<u32>

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

last_bytes: Option<usize>

The bytes of that frame.

Implementations

impl HevcEncoder

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

Open a session on host frames; rgba names the byte order they arrive in.

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

pub fn bit_depth(&self) -> u32

The bits per sample the session codes.

pub fn is_full_range(&self) -> bool

The software 4:4:4 of x264’s kind signals full range.

pub fn last_reference(&self) -> Reference

pub fn holds_quantizer(&self) -> bool

Whether hold_quantizer holds a frame at its quantizer: x265 at a constant rate factor, kvazaar never. At a constant rate x265’s rate control moves a forced quantizer back to what its buffer affords (a key frame held at 18 came out 23.2 kB at 26.6 dB at 8 Mbit/s 1080p), and a fresh session whose buffer is the key frame’s budget plans it from a fraction of that buffer (102.5 kB at 34 dB where the budget was 250 kB and the picture before it 53.9 dB), so a constant-rate session holds none.

pub fn reach_finer(&self) -> u32

The quantizer steps finer than the paint-over one at which a constant rate’s frames come to the paint-over quality (FrameEncoder::reach_finer): HEVC_REACH_FINER.

pub fn refines(&self) -> bool

Whether the session refines blocks of a frame of its rate control’s (refine_blocks): x265, through its per-block quantizer offsets, and kvazaar, through its map of a delta a 64x64 tree block, the finest of the blocks it holds.

pub fn refine_finer(&self) -> u32

Quality index steps finer than the paint-over one a refined block is coded at (FrameEncoder::refines): the library’s (Backend::REFINE_FINER).

pub fn refine_blocks(&mut self, refinement: &Refinement)

Code the blocks refinement names in the next frame of the rate control’s at its target quality (ledger): each 16x16 block it refines at the quantizer steps from the rate control’s last to the target, off the frame’s own.

pub fn constant_blocks(&mut self, constant: &[bool])

Mark the blocks of the next frame, in raster order, that held still and are clean (BlockLedger::constant), which x265 codes as skips without analysis (x265_picture.constantBlocks) on a frame of its rate control’s; kvazaar takes no such map. An empty slice marks none.

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

The quality index (HEVC’s quantizer) the rate control last coded a frame at, held frames aside.

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

The bytes the rate control spent on its last frame, held frames aside: its filler counted, as the rate control counts it, though the frame goes without it (Coded::spent).

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

The library keeps its reference lists to itself: refused, so the caller codes a key frame.

fn reopen(&mut self) -> Result<(), String>

Open a fresh encoder with the live settings, whose first frame is a key frame.

pub fn hold_quantizer(&mut self, crf: u32)

Encode the next frame at the quantizer the quality index crf selects, leaving the session’s own quality for the frame after: the cleanup of a still screen, at a constant rate factor, where x265 takes it as the frame’s forced quantizer. A constant-rate session codes the frame under its rate control (holds_quantizer). kvazaar takes no quantizer but the one it opens at, and a re-open for the frame would need another to come back, each a key frame, so it codes the frame at its own.

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

Re-open the encoder when a rate or frame-rate setting changed: neither library’s rate control takes a new target while it runs.

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.

Trait Implementations

impl Send for HevcEncoder