use std::mem::MaybeUninit;
use std::os::raw::{c_int, c_ulong};
use std::ptr;
use crate::codec::{Codec, VideoEncoder};
use crate::ffi::{self, check};
use crate::{EncodedFrame, EncoderConfig, Error, I420Frame, Result, TEMPORAL_LAYERS, vp9_threads};
const MAX_THREADS: u32 = 64;
struct Layering {
mode: c_int,
pattern: &'static [u32],
decimator: &'static [u32],
bitrate_percent: &'static [u32],
}
fn layering(layers: u8) -> Layering {
match layers {
1 => Layering {
mode: ffi::VP9E_TEMPORAL_LAYERING_MODE_NOLAYERING as c_int,
pattern: &[0],
decimator: &[1],
bitrate_percent: &[100],
},
2 => Layering {
mode: ffi::VP9E_TEMPORAL_LAYERING_MODE_0101 as c_int,
pattern: &[0, 1],
decimator: &[2, 1],
bitrate_percent: &[60, 100],
},
_ => Layering {
mode: ffi::VP9E_TEMPORAL_LAYERING_MODE_0212 as c_int,
pattern: &[0, 2, 1, 2],
decimator: &[4, 2, 1],
bitrate_percent: &[40, 60, 100],
},
}
}
const TIMEBASE_DEN: c_int = 1000;
const CPU_USED: c_int = 7;
pub struct Vp9Encoder {
ctx: Box<ffi::vpx_codec_ctx_t>,
cfg: Box<ffi::vpx_codec_enc_cfg_t>,
config: EncoderConfig,
layers: u8,
opened: (u32, u32),
}
unsafe impl Send for Vp9Encoder {}
impl Vp9Encoder {
pub fn new(config: EncoderConfig) -> Result<Self> {
Self::open(config, true)
}
pub fn natural(config: EncoderConfig) -> Result<Self> {
Self::open(config, false)
}
fn open(config: EncoderConfig, screen_content: bool) -> Result<Self> {
validate(&config)?;
let layers = config.temporal_layers.unwrap_or(TEMPORAL_LAYERS);
let layering = layering(layers);
unsafe {
let iface = ffi::vpx_codec_vp9_cx();
let mut cfg = Box::new(MaybeUninit::<ffi::vpx_codec_enc_cfg_t>::zeroed().assume_init());
let status = ffi::vpx_codec_enc_config_default(iface, &mut *cfg, 0);
check(ptr::null_mut(), status, "default encoder config")?;
cfg.g_w = config.width;
cfg.g_h = config.height;
cfg.g_timebase = ffi::vpx_rational {
num: 1,
den: TIMEBASE_DEN,
};
cfg.g_threads = config.threads.unwrap_or_else(vp9_threads);
cfg.g_lag_in_frames = 0;
cfg.g_error_resilient = ffi::VPX_ERROR_RESILIENT_DEFAULT;
cfg.g_pass = ffi::VPX_RC_ONE_PASS;
cfg.rc_end_usage = ffi::VPX_CBR;
cfg.rc_min_quantizer = 2;
cfg.rc_max_quantizer = 63;
cfg.rc_undershoot_pct = 50;
cfg.rc_overshoot_pct = 50;
cfg.rc_buf_initial_sz = 500;
cfg.rc_buf_optimal_sz = 600;
cfg.rc_buf_sz = 700;
cfg.rc_dropframe_thresh = 0;
cfg.kf_mode = ffi::VPX_KF_DISABLED;
cfg.ss_number_layers = 1;
cfg.ts_number_layers = u32::from(layers);
cfg.ts_periodicity = layering.pattern.len() as u32;
cfg.ts_layer_id[..layering.pattern.len()].copy_from_slice(layering.pattern);
cfg.ts_rate_decimator[..layering.decimator.len()].copy_from_slice(layering.decimator);
cfg.temporal_layering_mode = layering.mode;
set_layer_bitrates(&mut cfg, config.bitrate_kbps, layers);
let mut ctx = Box::new(MaybeUninit::<ffi::vpx_codec_ctx_t>::zeroed().assume_init());
let status = ffi::vpx_codec_enc_init_ver(
&mut *ctx,
iface,
&*cfg,
0,
ffi::VPX_ENCODER_ABI_VERSION as c_int,
);
check(&mut *ctx, status, "encoder init")?;
let mut encoder = Self {
ctx,
cfg,
config,
layers,
opened: (config.width, config.height),
};
encoder.configure_controls(screen_content)?;
Ok(encoder)
}
}
pub fn config(&self) -> EncoderConfig {
self.config
}
pub fn encode(
&mut self,
frame: &I420Frame,
pts: i64,
force_keyframe: bool,
) -> Result<Vec<EncodedFrame>> {
if frame.width() != self.cfg.g_w || frame.height() != self.cfg.g_h {
return Err(Error::InvalidFrame(format!(
"frame is {}x{}, encoder is set to {}x{}",
frame.width(),
frame.height(),
self.cfg.g_w,
self.cfg.g_h
)));
}
let flags = if force_keyframe {
ffi::VPX_EFLAG_FORCE_KF as ffi::vpx_enc_frame_flags_t
} else {
0
};
let duration = c_ulong::from(TIMEBASE_DEN as u32 / self.config.fps);
unsafe {
let img = wrap_image(frame);
let status = ffi::vpx_codec_encode(
&mut *self.ctx,
&img,
pts,
duration,
flags,
c_ulong::from(ffi::VPX_DL_REALTIME),
);
check(&mut *self.ctx, status, "encode")?;
let mut layer = MaybeUninit::<ffi::vpx_svc_layer_id_t>::zeroed().assume_init();
let status = ffi::vpx_codec_control_(
&mut *self.ctx,
ffi::VP9E_GET_SVC_LAYER_ID as c_int,
&mut layer as *mut ffi::vpx_svc_layer_id_t,
);
check(&mut *self.ctx, status, "read temporal layer id")?;
let temporal_layer = u8::try_from(layer.temporal_layer_id)
.ok()
.filter(|id| *id < self.layers)
.ok_or_else(|| Error::Codec {
library: "libvpx",
operation: "read temporal layer id",
message: format!("unexpected layer id {}", layer.temporal_layer_id),
})?;
let mut frames = Vec::new();
let mut iter: ffi::vpx_codec_iter_t = ptr::null();
loop {
let pkt = ffi::vpx_codec_get_cx_data(&mut *self.ctx, &mut iter);
if pkt.is_null() {
break;
}
if (*pkt).kind != ffi::VPX_CODEC_CX_FRAME_PKT {
continue;
}
let out = &(*pkt).data.frame;
frames.push(EncodedFrame {
data: std::slice::from_raw_parts(out.buf as *const u8, out.sz).to_vec(),
keyframe: out.flags & ffi::VPX_FRAME_IS_KEY != 0,
temporal_layer,
pts: out.pts,
});
}
Ok(frames)
}
}
pub fn set_resolution(&mut self, width: u32, height: u32) -> Result<()> {
if width == 0 || height == 0 {
return Err(Error::InvalidConfig(format!("size {width}x{height}")));
}
let config = EncoderConfig {
width,
height,
..self.config
};
validate(&config)?;
if width > self.opened.0 || height > self.opened.1 {
*self = Self::new(config)?;
return Ok(());
}
self.cfg.g_w = width;
self.cfg.g_h = height;
self.apply_config("set resolution")?;
self.config = config;
Ok(())
}
pub fn set_bitrate(&mut self, bitrate_kbps: u32) -> Result<()> {
if bitrate_kbps == 0 {
return Err(Error::InvalidConfig("bitrate 0".into()));
}
set_layer_bitrates(&mut self.cfg, bitrate_kbps, self.layers);
self.apply_config("set bitrate")?;
self.config.bitrate_kbps = bitrate_kbps;
Ok(())
}
pub fn set_fps(&mut self, fps: u32) -> Result<()> {
let config = EncoderConfig { fps, ..self.config };
validate(&config)?;
self.config = config;
Ok(())
}
fn apply_config(&mut self, operation: &'static str) -> Result<()> {
let status = unsafe { ffi::vpx_codec_enc_config_set(&mut *self.ctx, &*self.cfg) };
check(&mut *self.ctx, status, operation)
}
fn configure_controls(&mut self, screen_content: bool) -> Result<()> {
let multithreaded = c_int::from(self.cfg.g_threads > 1);
let controls: [(ffi::vp8e_enc_control_id, c_int, &'static str); 9] = [
(ffi::VP8E_SET_CPUUSED, CPU_USED, "set speed"),
(
ffi::VP9E_SET_TUNE_CONTENT,
if screen_content {
ffi::VP9E_CONTENT_SCREEN as c_int
} else {
ffi::VP9E_CONTENT_DEFAULT as c_int
},
"tune for the content",
),
(ffi::VP9E_SET_AQ_MODE, 3, "set aq mode"),
(ffi::VP8E_SET_STATIC_THRESHOLD, 1, "set static threshold"),
(ffi::VP9E_SET_TILE_COLUMNS, 2, "set tile columns"),
(
ffi::VP9E_SET_ROW_MT,
multithreaded,
"set row multithreading",
),
(
ffi::VP9E_SET_FRAME_PARALLEL_DECODING,
0,
"set frame parallel",
),
(ffi::VP9E_SET_NOISE_SENSITIVITY, 0, "disable denoiser"),
(ffi::VP9E_SET_SVC, 1, "enable temporal layers"),
];
let layered = self.layers > 1;
let count = controls.len() - usize::from(!layered);
for (id, value, operation) in &controls[..count] {
let status = unsafe { ffi::vpx_codec_control_(&mut *self.ctx, *id as c_int, *value) };
check(&mut *self.ctx, status, operation)?;
}
if !layered {
return Ok(());
}
let status = unsafe {
let mut svc = MaybeUninit::<ffi::vpx_svc_extra_cfg_t>::zeroed().assume_init();
for layer in 0..usize::from(self.layers) {
svc.max_quantizers[layer] = self.cfg.rc_max_quantizer as c_int;
svc.min_quantizers[layer] = self.cfg.rc_min_quantizer as c_int;
svc.scaling_factor_num[layer] = 1;
svc.scaling_factor_den[layer] = 1;
}
svc.temporal_layering_mode = self.cfg.temporal_layering_mode;
ffi::vpx_codec_control_(
&mut *self.ctx,
ffi::VP9E_SET_SVC_PARAMETERS as c_int,
&mut svc as *mut ffi::vpx_svc_extra_cfg_t,
)
};
check(&mut *self.ctx, status, "set layer parameters")
}
}
impl VideoEncoder for Vp9Encoder {
fn codec(&self) -> Codec {
Codec::Vp9
}
fn config(&self) -> EncoderConfig {
Vp9Encoder::config(self)
}
fn temporal_layers(&self) -> u8 {
self.layers
}
fn encode(
&mut self,
frame: &I420Frame,
pts: i64,
force_keyframe: bool,
) -> Result<Vec<EncodedFrame>> {
Vp9Encoder::encode(self, frame, pts, force_keyframe)
}
fn set_resolution(&mut self, width: u32, height: u32) -> Result<()> {
Vp9Encoder::set_resolution(self, width, height)
}
fn set_bitrate(&mut self, bitrate_kbps: u32) -> Result<()> {
Vp9Encoder::set_bitrate(self, bitrate_kbps)
}
fn set_fps(&mut self, fps: u32) -> Result<()> {
Vp9Encoder::set_fps(self, fps)
}
}
impl Drop for Vp9Encoder {
fn drop(&mut self) {
unsafe {
ffi::vpx_codec_destroy(&mut *self.ctx);
}
}
}
fn validate(config: &EncoderConfig) -> Result<()> {
if config.width == 0 || config.height == 0 {
return Err(Error::InvalidConfig(format!(
"size {}x{}",
config.width, config.height
)));
}
config.validate_common(TEMPORAL_LAYERS)?;
match config.threads {
Some(threads) if threads == 0 || threads > MAX_THREADS => Err(Error::InvalidConfig(
format!("{threads} threads (libvpx runs with 1 to {MAX_THREADS})"),
)),
_ => Ok(()),
}
}
fn set_layer_bitrates(cfg: &mut ffi::vpx_codec_enc_cfg_t, bitrate_kbps: u32, layers: u8) {
cfg.rc_target_bitrate = bitrate_kbps;
for (layer, percent) in layering(layers).bitrate_percent.iter().enumerate() {
let kbps = bitrate_kbps.saturating_mul(*percent) / 100;
cfg.ts_target_bitrate[layer] = kbps;
cfg.layer_target_bitrate[layer] = kbps;
}
}
unsafe fn wrap_image(frame: &I420Frame) -> ffi::vpx_image_t {
let (w, h) = (frame.width(), frame.height());
let chroma_w = w.div_ceil(2);
unsafe {
let mut img = MaybeUninit::<ffi::vpx_image_t>::zeroed().assume_init();
let base = frame.data().as_ptr() as *mut u8;
ffi::vpx_img_wrap(&mut img, ffi::VPX_IMG_FMT_I420, w, h, 1, base);
let luma = w as usize * h as usize;
let chroma = chroma_w as usize * h.div_ceil(2) as usize;
img.planes[0] = base;
img.planes[1] = base.add(luma);
img.planes[2] = base.add(luma + chroma);
img.stride[0] = w as c_int;
img.stride[1] = chroma_w as c_int;
img.stride[2] = chroma_w as c_int;
img
}
}
#[cfg(test)]
mod tests {
use super::*;
fn config() -> EncoderConfig {
EncoderConfig::new(320, 240, 30, 500)
}
fn frame() -> I420Frame {
I420Frame::new(320, 240, vec![128; I420Frame::buffer_len(320, 240)]).expect("frame")
}
fn layers_of(encoder: &mut Vp9Encoder, count: i64) -> Vec<u8> {
(0..count)
.map(|index| {
let out = encoder.encode(&frame(), index * 33, false).expect("encode");
out[0].temporal_layer
})
.collect()
}
#[test]
fn defaults_are_three_layers_and_automatic_threads() {
let mut encoder = Vp9Encoder::new(config()).expect("encoder");
assert_eq!(encoder.temporal_layers(), TEMPORAL_LAYERS);
assert_eq!(encoder.cfg.g_threads, vp9_threads());
assert_eq!(encoder.config(), config());
assert_eq!(layers_of(&mut encoder, 5), [0, 2, 1, 2, 0]);
}
#[test]
fn produces_the_requested_layers() {
let mut one = Vp9Encoder::new(config().with_temporal_layers(1)).expect("encoder");
assert_eq!(one.temporal_layers(), 1);
assert_eq!(layers_of(&mut one, 4), [0, 0, 0, 0]);
let mut two = Vp9Encoder::new(config().with_temporal_layers(2)).expect("encoder");
assert_eq!(two.temporal_layers(), 2);
assert_eq!(layers_of(&mut two, 4), [0, 1, 0, 1]);
two.set_bitrate(800).expect("bitrate");
assert_eq!(two.cfg.layer_target_bitrate[..2], [480, 800]);
}
fn noise(index: u32) -> I420Frame {
let mut state = index.wrapping_mul(2_654_435_761).wrapping_add(1);
let data = (0..I420Frame::buffer_len(320, 240))
.map(|_| {
state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
112 + (state >> 27) as u8
})
.collect();
I420Frame::new(320, 240, data).expect("frame")
}
fn measured_kbps(layers: u8, bitrate_kbps: u32) -> u32 {
let settings = EncoderConfig::new(320, 240, 30, bitrate_kbps).with_temporal_layers(layers);
let mut encoder = Vp9Encoder::new(settings).expect("encoder");
let mut bytes = 0;
for index in 0..60u32 {
let out = encoder
.encode(&noise(index), i64::from(index * 1000 / 30), false)
.expect("encode");
if index >= 30 {
bytes += out.iter().map(|frame| frame.data.len()).sum::<usize>();
}
}
(bytes * 8 / 1000) as u32
}
#[test]
fn the_output_size_follows_the_bitrate_with_one_and_two_layers() {
for layers in [1, 2] {
for target in [500, 1500, 4000] {
let measured = measured_kbps(layers, target);
assert!(
(target * 7 / 10..=target * 13 / 10).contains(&measured),
"{layers} layers at {target} kbit/s: {measured} kbit/s"
);
}
}
}
#[test]
fn uses_the_requested_threads() {
let encoder = Vp9Encoder::new(config().with_threads(1)).expect("encoder");
assert_eq!(encoder.cfg.g_threads, 1);
let encoder = Vp9Encoder::new(config().with_threads(64)).expect("encoder");
assert_eq!(encoder.cfg.g_threads, 64);
}
#[test]
fn rejects_settings_it_cannot_honour() {
for invalid in [
EncoderConfig { fps: 0, ..config() },
EncoderConfig {
fps: 121,
..config()
},
config().with_temporal_layers(0),
config().with_temporal_layers(4),
config().with_threads(0),
config().with_threads(65),
config().with_max_size(319, 240),
] {
assert!(matches!(
Vp9Encoder::new(invalid),
Err(Error::InvalidConfig(_))
));
}
}
#[test]
fn accepts_120_fps_and_keeps_the_settings_across_changes() {
let settings = config().with_temporal_layers(2).with_max_size(640, 480);
let mut encoder = Vp9Encoder::new(EncoderConfig {
fps: 120,
..settings
})
.expect("encoder");
encoder.set_fps(60).expect("fps");
assert!(matches!(encoder.set_fps(121), Err(Error::InvalidConfig(_))));
encoder.set_resolution(640, 480).expect("grow");
assert_eq!(encoder.temporal_layers(), 2);
assert!(matches!(
encoder.set_resolution(641, 480),
Err(Error::InvalidConfig(_))
));
assert_eq!(
encoder.config(),
EncoderConfig {
width: 640,
height: 480,
fps: 60,
..settings
}
);
}
}