Struct Backend 

pub struct Backend {
    api: *const x265_api,
    params: *mut x265_param,
    encoder: *mut x265_encoder,
    layout: InputLayout,
    pictures: [[Vec<u64>; 3]; 2],
    aligned: [[usize; 3]; 2],
    current: usize,
}

Fields

api: *const x265_api

params: *mut x265_param

encoder: *mut x265_encoder

layout: InputLayout

How the session lays out a source picture, which pictures follow.

pictures: [[Vec<u64>; 3]; 2]

Two pictures, three planes each, converted into in turn: x265 reads a picture through the encode it is passed to, and the other holds the frame before while it is read. Each plane is 64-byte aligned within its buffer at aligned.

aligned: [[usize; 3]; 2]

current: usize

Implementations

impl Backend

pub const LIBRARY: &'static str = "x265"

pub const FULLCOLOR: bool = true

pub const KEY_ON_REQUEST: bool = true

pub const HOLDS_QUANTIZER: bool = true

pub const REFINES: bool = true

pub const CONSTANT_BLOCKS: bool = true

pub const REFINE_FINER: u32 = 6

Quality index steps finer than the paint-over one x265 codes a refined block at (FrameEncoder::refines). Its ultrafast analysis settles many a still block on its merge candidate before the offset’s quantizer counts, so refining takes 1080p text beside a video less far than its cleanup of the still screen does, and every step finer gains: at 8 Mbit/s from 31.1 dB to 34.2, 35.5, and 36.3 at 0, 3, and 6 steps finer, against 46.4 still; at a constant quality from 37.7 to 40.7, 41.6, and 42.7, against 49.6; the video losing 0.3 dB.

pub fn ten_bit() -> bool

Whether the linked x265 carries a 10-bit encoder beside its 8-bit one, which is a property of how the library was built.

fn set(&self, name: &str, value: &str) -> Result<(), String>

fn rate_options(rate: RateSettings, q: u32) -> Vec<(&'static str, String)>

The rate-control options of rate at quantizer q: a constant rate held to its VBV with the quantizer capped at 51, since the library’s default ceiling admits out-of-spec quantizers that only force skips on a VBV underflow; else a constant rate factor.

pub fn open( width: usize, height: usize, threads: i32, i444: bool, bit_depth: u32, rate: RateSettings, q: u32, ) -> Result<Self, String>

fn plane(&mut self, picture: usize, p: usize) -> (*mut u8, usize)

The first pixel of plane p of picture picture, and the bytes from it to the buffer’s end.

pub fn encode( &mut self, planes: &mut Planes, pixels: &[u8], stride: usize, rgba: bool, full_range: bool, threads: usize, pts: u64, key: bool, held: Option<u32>, offsets: Option<&mut [f32]>, constant: Option<&mut [u8]>, ) -> Result<Option<Coded>, String>

Convert the host frame into the next in-place picture and encode it there. constant marks the 16x16 blocks x265 codes as skips without analysis.

Trait Implementations

impl Drop for Backend

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.