use std::time::Duration;
use bytes::Bytes;
use hang::catalog::VideoCodec;
use crate::clock::StreamClock;
use crate::convert::{I420, Planes, yuv_to_packed};
use crate::{Error, Image, PixelFormat, Result};
mod annexb;
#[cfg(feature = "av1")]
mod av1;
#[cfg(feature = "hw")]
mod gst;
#[cfg(feature = "h264")]
mod h264;
mod obu;
#[cfg(feature = "vp8")]
mod vp8;
mod vp8_header;
#[cfg(feature = "h264")]
pub use h264::set_openh264_library;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum Codec {
Vp8,
H264,
Av1,
}
impl Codec {
#[cfg(test)]
pub(crate) const ALL: &[Codec] = &[Codec::Vp8, Codec::H264, Codec::Av1];
pub const fn available() -> &'static [Codec] {
&[
#[cfg(feature = "vp8")]
Codec::Vp8,
#[cfg(feature = "av1")]
Codec::Av1,
#[cfg(feature = "h264")]
Codec::H264,
]
}
pub fn is_available(self) -> bool {
Self::available().contains(&self)
}
pub fn from_catalog(codec: &VideoCodec) -> Option<Self> {
match codec {
VideoCodec::VP8 => Some(Self::Vp8),
VideoCodec::H264(_) => Some(Self::H264),
VideoCodec::AV1(_) => Some(Self::Av1),
_ => None,
}
}
pub fn is_keyframe(self, data: &[u8]) -> bool {
match self {
Self::Vp8 => vp8_header::is_keyframe(data),
Self::H264 => annexb::is_keyframe(data),
Self::Av1 => obu::is_keyframe(data),
}
}
pub(crate) fn catalog_codec(self, keyframe: &[u8]) -> VideoCodec {
match self {
Self::Vp8 => VideoCodec::VP8,
Self::H264 => annexb::catalog_codec(keyframe),
Self::Av1 => obu::catalog_codec(keyframe),
}
}
}
crate::names::named_enum!(Codec, "codec", {
Vp8 => "vp8",
H264 => "h264" | "avc",
Av1 => "av1" | "av01",
});
impl Default for Codec {
fn default() -> Self {
Self::available().first().copied().unwrap_or(Self::Vp8)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[non_exhaustive]
pub enum Hardware {
Off,
#[default]
Auto,
Require,
}
crate::names::named_enum!(Hardware, "hardware mode", {
Off => "off",
Auto => "auto",
Require => "require",
});
#[derive(Debug, Clone)]
pub struct EncoderSettings {
pub codec: Codec,
pub bitrate: u32,
pub max_fps: f32,
pub keyframe_interval: Duration,
pub threads: u16,
pub hardware: Hardware,
}
impl Default for EncoderSettings {
fn default() -> Self {
Self {
codec: Codec::default(),
bitrate: 2_000_000,
max_fps: 30.0,
keyframe_interval: Duration::from_secs(2),
threads: 0,
hardware: Hardware::default(),
}
}
}
impl EncoderSettings {
pub(crate) fn threads(&self) -> u32 {
match self.threads {
0 => default_threads(),
n => u32::from(n),
}
}
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "float casts saturate"
)]
pub(crate) fn gop_frames(&self) -> u32 {
(self.max_fps * self.keyframe_interval.as_secs_f32() * 2.0)
.ceil()
.max(1.0) as u32
}
#[expect(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "float casts saturate"
)]
pub(crate) fn frame_duration_micros(&self) -> u64 {
(1_000_000.0 / self.max_fps.max(1.0)) as u64
}
}
pub(crate) fn default_threads() -> u32 {
std::thread::available_parallelism().map_or(1, |n| u32::try_from(n.get()).unwrap_or(4).min(4))
}
#[derive(Debug, Clone)]
pub struct EncodedFrame {
pub data: Bytes,
pub keyframe: bool,
pub width: u32,
pub height: u32,
pub timestamp: Duration,
pub codec: VideoCodec,
}
pub(crate) struct EncodedChunk {
pub data: Bytes,
pub keyframe: bool,
}
pub(crate) trait EncoderBackend: Send {
fn encode(&mut self, frame: &I420, pts: u64, force_keyframe: bool) -> Result<Option<EncodedChunk>>;
fn set_bitrate(&mut self, bitrate: u32) -> Result<bool> {
let _ = bitrate;
Ok(false)
}
}
pub(crate) trait DecoderBackend: Send {
fn decode(&mut self, data: &[u8], max_pixels: u64, format: PixelFormat) -> Result<Option<(u32, u32, Vec<u8>)>>;
}
pub(crate) fn packed_picture(planes: &Planes<'_>, max_pixels: u64, format: PixelFormat) -> Result<(u32, u32, Vec<u8>)> {
let dim = |n: usize| u32::try_from(n).unwrap_or(u32::MAX);
let (width, height) = (dim(planes.width), dim(planes.height));
check_size(width, height, max_pixels)?;
Ok((width, height, yuv_to_packed(planes, format)?))
}
pub const DEFAULT_MAX_PIXELS: u64 = 7680 * 4320;
pub(crate) fn check_size(width: u32, height: u32, max: u64) -> Result<()> {
if u64::from(width) * u64::from(height) > max {
return Err(Error::TooLarge { width, height, max });
}
Ok(())
}
pub struct Encoder {
settings: EncoderSettings,
active: Option<ActiveBackend>,
hardware: Option<&'static str>,
last_keyframe: Option<u64>,
clock: StreamClock,
yuv: I420,
}
struct ActiveBackend {
backend: Box<dyn EncoderBackend>,
dims: (usize, usize),
codec: Option<VideoCodec>,
}
impl ActiveBackend {
fn new(backend: Box<dyn EncoderBackend>, dims: (usize, usize)) -> Self {
Self {
backend,
dims,
codec: None,
}
}
}
impl Encoder {
pub fn new(settings: EncoderSettings) -> Result<Self> {
if !settings.codec.is_available() {
return Err(unavailable(settings.codec));
}
if settings.hardware == Hardware::Require && !cfg!(feature = "hw") {
return Err(Error::CodecUnavailable(
"hardware encoding is not compiled in (enable the `hw` feature)".into(),
));
}
Ok(Self {
settings,
active: None,
hardware: None,
last_keyframe: None,
clock: StreamClock::default(),
yuv: I420::default(),
})
}
pub fn settings(&self) -> &EncoderSettings {
&self.settings
}
pub fn hardware_encoder(&self) -> Option<&'static str> {
self.hardware
}
pub fn set_bitrate(&mut self, bitrate: u32) {
if bitrate == self.settings.bitrate {
return;
}
self.settings.bitrate = bitrate;
let Some(active) = self.active.as_mut() else {
return;
};
match active.backend.set_bitrate(bitrate) {
Ok(true) => tracing::debug!(codec = %self.settings.codec, bitrate, "changed the bitrate"),
Ok(false) => {
tracing::debug!(codec = %self.settings.codec, bitrate, "recreating the encoder for the new bitrate");
self.active = None;
}
Err(err) => {
tracing::warn!(codec = %self.settings.codec, bitrate, %err, "changing the bitrate failed; recreating the encoder");
self.active = None;
}
}
}
pub fn force_keyframe(&mut self) {
self.last_keyframe = None;
}
pub fn encode(&mut self, image: &Image) -> Result<Option<EncodedFrame>> {
self.yuv.fill_from_image(image)?;
let yuv = std::mem::take(&mut self.yuv);
let frame = self.encode_yuv(&yuv, image.timestamp);
self.yuv = yuv;
frame
}
#[expect(
clippy::cast_possible_truncation,
reason = "I420 dimensions come from `u32` image dimensions"
)]
pub(crate) fn encode_yuv(&mut self, yuv: &I420, timestamp: Duration) -> Result<Option<EncodedFrame>> {
let dims = (yuv.width(), yuv.height());
if self.active.as_ref().is_none_or(|active| active.dims != dims) {
tracing::debug!(codec = %self.settings.codec, width = dims.0, height = dims.1, "creating encoder");
self.active = None;
self.active = Some(ActiveBackend::new(self.create_backend(dims)?, dims));
self.last_keyframe = None;
}
let pts = self.clock.micros(timestamp);
let interval = u64::try_from(self.settings.keyframe_interval.as_micros()).unwrap_or(u64::MAX);
let force = self
.last_keyframe
.is_none_or(|last| pts.saturating_sub(last) >= interval);
let Some(EncodedChunk { data, keyframe }) = self.encode_with_fallback(yuv, pts, force)? else {
return Ok(None);
};
if keyframe {
self.last_keyframe = Some(pts);
}
let active = self.active.as_mut().expect("backend created above");
let codec = match &active.codec {
Some(codec) if !keyframe => codec.clone(),
_ => active.codec.insert(self.settings.codec.catalog_codec(&data)).clone(),
};
Ok(Some(EncodedFrame {
data,
keyframe,
width: dims.0 as u32,
height: dims.1 as u32,
timestamp,
codec,
}))
}
fn encode_with_fallback(&mut self, yuv: &I420, pts: u64, force: bool) -> Result<Option<EncodedChunk>> {
let active = self.active.as_mut().expect("backend created before encoding");
let dims = active.dims;
match active.backend.encode(yuv, pts, force) {
Ok(chunk) => Ok(chunk),
Err(err) if self.hardware.is_some() && self.settings.hardware == Hardware::Auto => {
tracing::warn!(codec = %self.settings.codec, element = self.hardware, %err, "hardware encoder failed; encoding in software");
self.hardware = None;
self.active = None;
let backend = create_software_encoder(&self.settings, dims)?;
let active = self.active.insert(ActiveBackend::new(backend, dims));
active.backend.encode(yuv, pts, true)
}
Err(err) => {
if self.hardware.is_some() {
self.active = None;
}
Err(err)
}
}
}
fn create_backend(&mut self, dims: (usize, usize)) -> Result<Box<dyn EncoderBackend>> {
#[cfg(feature = "hw")]
if self.settings.hardware != Hardware::Off {
let first_attempt = gst::first_attempt(self.settings.codec, dims);
match gst::GstEncoder::new(&self.settings, dims, self.hardware) {
Ok(encoder) => {
if self.hardware != Some(encoder.element()) {
tracing::info!(codec = %self.settings.codec, element = encoder.element(), "using hardware encoder");
}
self.hardware = Some(encoder.element());
return Ok(Box::new(encoder));
}
Err(err) if self.settings.hardware == Hardware::Require => return Err(err),
Err(err) => {
if first_attempt {
tracing::warn!(codec = %self.settings.codec, %err, "no usable hardware encoder; encoding in software");
} else {
tracing::debug!(codec = %self.settings.codec, %err, "no usable hardware encoder; encoding in software");
}
self.hardware = None;
}
}
}
create_software_encoder(&self.settings, dims)
}
}
pub struct Decoder {
codec: Codec,
inner: Box<dyn DecoderBackend>,
max_pixels: u64,
output: PixelFormat,
}
impl Decoder {
pub fn new(codec: Codec) -> Result<Self> {
let inner: Box<dyn DecoderBackend> = match codec {
#[cfg(feature = "vp8")]
Codec::Vp8 => Box::new(vp8::Vp8Decoder::new()?),
#[cfg(feature = "h264")]
Codec::H264 => Box::new(h264::H264Decoder::new()?),
#[cfg(feature = "av1")]
Codec::Av1 => Box::new(av1::Av1Decoder::new()?),
#[allow(unreachable_patterns)]
other => return Err(unavailable(other)),
};
Ok(Self {
codec,
inner,
max_pixels: DEFAULT_MAX_PIXELS,
output: PixelFormat::Rgb8,
})
}
pub fn codec(&self) -> Codec {
self.codec
}
pub fn max_pixels(&self) -> u64 {
self.max_pixels
}
pub fn set_max_pixels(&mut self, max_pixels: u64) {
self.max_pixels = max_pixels;
}
pub fn output_format(&self) -> PixelFormat {
self.output
}
pub fn set_output_format(&mut self, format: PixelFormat) -> Result<()> {
if matches!(format, PixelFormat::Uyvy | PixelFormat::Yuyv) {
return Err(Error::InvalidSettings(format!("can't decode into {format}")));
}
self.output = format;
Ok(())
}
pub fn decode(&mut self, data: &[u8], timestamp: Duration) -> Result<Option<Image>> {
let Some((width, height, pixels)) = self.inner.decode(data, self.max_pixels, self.output)? else {
return Ok(None);
};
Ok(Some(Image::new(width, height, self.output, pixels, timestamp)?))
}
}
#[expect(
clippy::cast_possible_truncation,
reason = "I420 dimensions come from `u32` image dimensions"
)]
fn create_software_encoder(
settings: &EncoderSettings,
(width, height): (usize, usize),
) -> Result<Box<dyn EncoderBackend>> {
Ok(match settings.codec {
#[cfg(feature = "vp8")]
Codec::Vp8 => Box::new(vp8::Vp8Encoder::new(settings, width as u32, height as u32)?),
#[cfg(feature = "h264")]
Codec::H264 => Box::new(h264::H264Encoder::new(settings)?),
#[cfg(feature = "av1")]
Codec::Av1 => Box::new(av1::Av1Encoder::new(settings, width as u32, height as u32)?),
#[allow(unreachable_patterns)]
other => {
let _ = (width, height);
return Err(unavailable(other));
}
})
}
fn unavailable(codec: Codec) -> Error {
Error::CodecUnavailable(format!(
"{codec} support is not compiled in (enable the `{codec}` feature)"
))
}
#[cfg(test)]
pub(crate) mod tests {
use super::*;
#[expect(clippy::cast_possible_truncation, reason = "the pattern wraps around")]
pub(crate) fn test_pattern(w: u32, h: u32, t: u32) -> Image {
let rgb: Vec<u8> = (0..h)
.flat_map(|y| (0..w).flat_map(move |x| [((x + t * 4) % 256) as u8, (y % 256) as u8, 100]))
.collect();
Image::new(w, h, PixelFormat::Rgb8, rgb, Duration::from_millis(u64::from(t) * 33)).unwrap()
}
pub(crate) fn round_trip(codec: Codec) {
let mut encoder = Encoder::new(EncoderSettings {
codec,
bitrate: 4_000_000,
..Default::default()
})
.unwrap();
let mut decoder = Decoder::new(codec).unwrap();
let mut decoded = 0;
let mut keyframe_codec = None;
for t in 0..10 {
let image = test_pattern(64, 48, t);
let Some(frame) = encoder.encode(&image).unwrap() else {
continue;
};
assert_eq!(Codec::from_catalog(&frame.codec), Some(codec));
let keyframe_codec = keyframe_codec.get_or_insert_with(|| frame.codec.clone());
assert_eq!(&frame.codec, keyframe_codec);
assert_eq!(codec.is_keyframe(&frame.data), frame.keyframe);
if t == 0 {
assert!(frame.keyframe, "first frame must be a keyframe");
}
if let Some(out) = decoder.decode(&frame.data, frame.timestamp).unwrap() {
assert_eq!((out.width, out.height), (64, 48));
assert_eq!(out.timestamp, image.timestamp);
let err = out
.data
.iter()
.zip(image.data.iter())
.map(|(a, b)| u64::from(a.abs_diff(*b)))
.sum::<u64>() / out.data.len() as u64;
assert!(err < 12, "{codec}: mean abs error {err}");
decoded += 1;
}
}
assert!(decoded >= 9, "{codec}: decoded {decoded} frames");
}
pub(crate) fn keyframes(codec: Codec) {
let mut encoder = Encoder::new(EncoderSettings {
codec,
keyframe_interval: Duration::from_millis(100),
..Default::default()
})
.unwrap();
let keyframes: Vec<bool> = (0..8)
.filter_map(|t| encoder.encode(&test_pattern(32, 32, t)).unwrap())
.map(|f| f.keyframe)
.collect();
assert!(keyframes[0]);
assert!(keyframes.iter().filter(|k| **k).count() >= 2, "{keyframes:?}");
let frame = encoder.encode(&test_pattern(48, 32, 9)).unwrap().unwrap();
assert!(frame.keyframe, "resolution change restarts with a keyframe");
assert_eq!((frame.width, frame.height), (48, 32));
}
pub(crate) fn pixel_formats(codec: Codec) {
let mut encoder = Encoder::new(EncoderSettings {
codec,
..Default::default()
})
.unwrap();
let mut decoder = Decoder::new(codec).unwrap();
for (t, format) in [
PixelFormat::Rgb8,
PixelFormat::Bgr8,
PixelFormat::Rgba8,
PixelFormat::Bgra8,
PixelFormat::Mono8,
PixelFormat::Uyvy,
PixelFormat::Yuyv,
]
.into_iter()
.enumerate()
{
let (width, height) = (33u32, 25u32);
let data = vec![128u8; (width * height) as usize * format.bytes_per_pixel()];
let timestamp = Duration::from_millis(t as u64 * 33);
let image = Image::new(width, height, format, data, timestamp).unwrap();
encoder.force_keyframe();
let frame = encoder
.encode(&image)
.unwrap()
.expect("forced keyframes aren't dropped");
assert!(frame.keyframe, "{codec} {format}");
assert_eq!((frame.width, frame.height), (32, 24), "{codec} {format}");
let out = decoder
.decode(&frame.data, timestamp)
.unwrap()
.expect("keyframe decodes");
assert_eq!((out.width, out.height, out.format), (32, 24, PixelFormat::Rgb8));
}
}
pub(crate) fn irregular_timestamps(codec: Codec) {
let mut encoder = Encoder::new(EncoderSettings {
codec,
..Default::default()
})
.unwrap();
for millis in [1000, 1000, 500, 1033] {
let mut image = test_pattern(32, 32, 0);
image.timestamp = Duration::from_millis(millis);
if let Some(frame) = encoder.encode(&image).unwrap() {
assert_eq!(frame.timestamp, image.timestamp);
}
}
}
pub(crate) fn forced_keyframe(codec: Codec) {
let mut encoder = Encoder::new(EncoderSettings {
codec,
keyframe_interval: Duration::from_secs(60),
..Default::default()
})
.unwrap();
for t in 0..4 {
if t == 2 {
encoder.force_keyframe();
}
let frame = encoder.encode(&test_pattern(32, 32, t)).unwrap();
match t {
0 | 2 => assert!(frame.expect("forced keyframes aren't dropped").keyframe, "frame {t}"),
_ => assert!(frame.is_none_or(|frame| !frame.keyframe), "frame {t}"),
}
}
}
pub(crate) fn rejects_invalid_images(codec: Codec) {
let mut encoder = Encoder::new(EncoderSettings {
codec,
keyframe_interval: Duration::from_secs(60),
..Default::default()
})
.unwrap();
assert!(encoder.encode(&test_pattern(32, 32, 0)).unwrap().unwrap().keyframe);
let tiny = Image::new(1, 1, PixelFormat::Rgb8, vec![0u8; 3], Duration::from_millis(33)).unwrap();
assert!(matches!(encoder.encode(&tiny), Err(Error::InvalidImage(_))));
if let Some(frame) = encoder.encode(&test_pattern(32, 32, 2)).unwrap() {
assert!(!frame.keyframe);
assert_eq!((frame.width, frame.height), (32, 32));
}
}
#[expect(clippy::cast_possible_truncation, reason = "the noise wraps around")]
fn noise(w: u32, h: u32, t: u32) -> Image {
let mut state = 0x9e37_79b9_u32 ^ t.wrapping_mul(0x85eb_ca6b);
let rgb: Vec<u8> = (0..w * h * 3)
.map(|_| {
state ^= state << 13;
state ^= state >> 17;
state ^= state << 5;
state as u8
})
.collect();
Image::new(w, h, PixelFormat::Rgb8, rgb, Duration::from_millis(u64::from(t) * 33)).unwrap()
}
pub(crate) fn bitrate_changes(codec: Codec) {
let mut encoder = Encoder::new(EncoderSettings {
codec,
bitrate: 2_000_000,
keyframe_interval: Duration::from_secs(60),
hardware: Hardware::Off,
..Default::default()
})
.unwrap();
let size = |encoder: &mut Encoder, frames: std::ops::Range<u32>| -> usize {
frames
.filter_map(|t| encoder.encode(&noise(128, 96, t)).unwrap())
.filter(|frame| !frame.keyframe)
.map(|frame| frame.data.len())
.sum()
};
let high = size(&mut encoder, 0..30);
encoder.set_bitrate(200_000);
assert_eq!(encoder.settings().bitrate, 200_000);
size(&mut encoder, 30..40);
let low = size(&mut encoder, 40..70);
assert!(low * 2 < high, "{codec}: {high} bytes at 2 Mbit/s, {low} at 200 kbit/s");
}
pub(crate) fn rejects_oversized_pictures(codec: Codec) {
let mut encoder = Encoder::new(EncoderSettings {
codec,
..Default::default()
})
.unwrap();
let frame = encoder.encode(&test_pattern(64, 48, 0)).unwrap().unwrap();
let mut decoder = Decoder::new(codec).unwrap();
assert_eq!(decoder.max_pixels(), DEFAULT_MAX_PIXELS);
decoder.set_max_pixels(64 * 48 - 1);
assert!(matches!(
decoder.decode(&frame.data, frame.timestamp),
Err(Error::TooLarge {
width: 64,
height: 48,
..
})
));
let mut decoder = Decoder::new(codec).unwrap();
decoder.set_max_pixels(64 * 48);
assert!(decoder.decode(&frame.data, frame.timestamp).unwrap().is_some());
}
pub(crate) fn keyframe_after_clock_jump(codec: Codec) {
let mut encoder = Encoder::new(EncoderSettings {
codec,
keyframe_interval: Duration::from_secs(1),
..Default::default()
})
.unwrap();
let mut encode = |millis: u64| {
let mut image = test_pattern(32, 32, 0);
image.timestamp = Duration::from_millis(millis);
encoder.encode(&image).unwrap()
};
assert!(encode(100_000).expect("first frame is a keyframe").keyframe);
for millis in [100_033, 100_032, 0, 500] {
assert!(encode(millis).is_none_or(|frame| !frame.keyframe), "{millis}ms");
}
let frame = encode(1_000).expect("forced keyframes aren't dropped");
assert!(frame.keyframe, "a second passed since the first keyframe");
}
#[test]
fn decodes_into_each_output_format() {
let Some(&codec) = Codec::available().first() else {
return;
};
if codec == Codec::H264 && std::env::var_os("OPENH264_LIBRARY").is_none() {
return;
}
let mut encoder = Encoder::new(EncoderSettings {
codec,
hardware: Hardware::Off,
..Default::default()
})
.unwrap();
let frame = encoder.encode(&test_pattern(64, 48, 0)).unwrap().unwrap();
let rgb = Decoder::new(codec)
.unwrap()
.decode(&frame.data, frame.timestamp)
.unwrap()
.unwrap();
for format in [
PixelFormat::Bgr8,
PixelFormat::Rgba8,
PixelFormat::Bgra8,
PixelFormat::Mono8,
] {
let mut decoder = Decoder::new(codec).unwrap();
decoder.set_output_format(format).unwrap();
assert_eq!(decoder.output_format(), format);
let image = decoder.decode(&frame.data, frame.timestamp).unwrap().unwrap();
assert_eq!((image.width, image.height, image.format), (64, 48, format));
if format == PixelFormat::Bgr8 {
assert_eq!((image.data[0], image.data[2]), (rgb.data[2], rgb.data[0]));
}
}
let mut decoder = Decoder::new(codec).unwrap();
assert!(matches!(
decoder.set_output_format(PixelFormat::Uyvy),
Err(Error::InvalidSettings(_))
));
assert_eq!(decoder.output_format(), PixelFormat::Rgb8);
}
#[test]
fn codec_names() {
assert_eq!("vp8".parse::<Codec>().unwrap(), Codec::Vp8);
assert_eq!("H264".parse::<Codec>().unwrap(), Codec::H264);
assert_eq!("AV1".parse::<Codec>().unwrap(), Codec::Av1);
assert!("vp9".parse::<Codec>().is_err());
assert!(Codec::Vp8.is_keyframe(&[0x10, 0x02, 0x00]));
assert!(!Codec::Vp8.is_keyframe(&[0x11, 0x02, 0x00]));
}
#[test]
fn codec_names_round_trip() {
for &codec in Codec::ALL {
assert_eq!(codec.to_string().parse::<Codec>().unwrap(), codec);
}
assert_eq!("AVC".parse::<Codec>().unwrap(), Codec::H264);
assert_eq!("av01".parse::<Codec>().unwrap(), Codec::Av1);
assert!(matches!("".parse::<Codec>(), Err(Error::InvalidSettings(_))));
}
#[test]
fn codecs_from_catalog() {
assert_eq!(Codec::from_catalog(&VideoCodec::VP8), Some(Codec::Vp8));
let avc: VideoCodec = "avc3.42001f".parse().unwrap();
assert_eq!(Codec::from_catalog(&avc), Some(Codec::H264));
let av1: VideoCodec = "av01.0.04M.08".parse().unwrap();
assert_eq!(Codec::from_catalog(&av1), Some(Codec::Av1));
assert_eq!(Codec::from_catalog(&VideoCodec::Unknown("hev2".into())), None);
}
#[test]
fn detects_h264_keyframes_by_idr_nal() {
let sps_pps_idr = [0, 0, 0, 1, 0x67, 1, 0, 0, 1, 0x68, 2, 0, 0, 1, 0x65, 3];
assert!(Codec::H264.is_keyframe(&sps_pps_idr));
assert!(!Codec::H264.is_keyframe(&[0, 0, 0, 1, 0x41, 3]));
assert!(!Codec::H264.is_keyframe(&[0, 0, 0, 1, 0x67, 1]));
assert!(!Codec::H264.is_keyframe(&[]));
assert!(!Codec::Vp8.is_keyframe(&[]));
}
#[test]
fn default_codec_is_compiled_in() {
if !Codec::available().is_empty() {
assert!(Codec::default().is_available());
assert_eq!(Codec::default(), Codec::available()[0]);
}
}
#[test]
fn missing_codecs_are_reported() {
for &codec in Codec::ALL {
if !codec.is_available() {
let settings = EncoderSettings {
codec,
..Default::default()
};
assert!(matches!(Encoder::new(settings), Err(Error::CodecUnavailable(_))));
assert!(matches!(Decoder::new(codec), Err(Error::CodecUnavailable(_))));
}
}
}
#[test]
fn hardware_modes() {
for mode in [Hardware::Off, Hardware::Auto, Hardware::Require] {
assert_eq!(mode.to_string().parse::<Hardware>().unwrap(), mode);
}
assert_eq!("AUTO".parse::<Hardware>().unwrap(), Hardware::Auto);
assert!(matches!("on".parse::<Hardware>(), Err(Error::InvalidSettings(_))));
assert_eq!(EncoderSettings::default().hardware, Hardware::Auto);
}
#[test]
fn hardware_off_encodes_in_software() {
let Some(&codec) = Codec::available().first() else {
return;
};
let mut encoder = Encoder::new(EncoderSettings {
codec,
hardware: Hardware::Off,
..Default::default()
})
.unwrap();
if codec == Codec::H264 && std::env::var_os("OPENH264_LIBRARY").is_none() {
return;
}
assert!(encoder.encode(&test_pattern(32, 32, 0)).unwrap().unwrap().keyframe);
assert_eq!(encoder.hardware_encoder(), None);
}
#[cfg(not(feature = "hw"))]
#[test]
fn required_hardware_needs_the_hw_feature() {
let settings = EncoderSettings {
hardware: Hardware::Require,
..Default::default()
};
if settings.codec.is_available() {
assert!(matches!(Encoder::new(settings), Err(Error::CodecUnavailable(_))));
}
}
#[test]
fn encoder_settings_derived_values() {
let settings = EncoderSettings::default();
assert_eq!(settings.gop_frames(), 120);
assert!((1..=4).contains(&settings.threads()));
let settings = EncoderSettings {
max_fps: 29.97,
keyframe_interval: Duration::from_secs(1),
threads: 8,
..Default::default()
};
assert_eq!(settings.gop_frames(), 60);
assert_eq!(settings.threads(), 8);
let settings = EncoderSettings {
keyframe_interval: Duration::ZERO,
..Default::default()
};
assert_eq!(settings.gop_frames(), 1);
}
}