use std::ffi::{CStr, c_char, c_int, c_uint, c_void};
use std::ptr;
use libloading::Library;
use super::{HardwareEncoder, Probe, dl, ffi::nvenc as nv};
use crate::detect::UnavailableReason;
use crate::{Codec, EncodedFrame, EncoderConfig, Error, I420Frame, Result, VideoEncoder};
const ENCODER: HardwareEncoder = HardwareEncoder::Nvenc;
#[cfg(windows)]
const CUDA: &[&str] = &["nvcuda.dll"];
#[cfg(not(windows))]
const CUDA: &[&str] = &["libcuda.so.1"];
const MAX_LAYERS: u8 = 4;
fn wanted_layers(fps: u32) -> u8 {
if fps >= 60 { MAX_LAYERS } else { 3 }
}
fn config_layers(config: &EncoderConfig) -> u8 {
config
.temporal_layers
.unwrap_or_else(|| wanted_layers(config.fps))
}
const fn struct_version(version: u32) -> u32 {
nv::NVENCAPI_VERSION | (version << 16) | (0x7 << 28)
}
const CAPS_PARAM_VER: u32 = struct_version(1);
const CREATE_INPUT_BUFFER_VER: u32 = struct_version(2);
const CREATE_BITSTREAM_BUFFER_VER: u32 = struct_version(1);
const CONFIG_VER: u32 = struct_version(9) | (1 << 31);
const INITIALIZE_PARAMS_VER: u32 = struct_version(7) | (1 << 31);
const RECONFIGURE_PARAMS_VER: u32 = struct_version(2) | (1 << 31);
const PRESET_CONFIG_VER: u32 = struct_version(5) | (1 << 31);
const PIC_PARAMS_VER: u32 = struct_version(7) | (1 << 31);
const LOCK_BITSTREAM_VER: u32 = struct_version(2) | (1 << 31);
const LOCK_INPUT_BUFFER_VER: u32 = struct_version(1);
const OPEN_SESSION_VER: u32 = struct_version(1);
const FUNCTION_LIST_VER: u32 = struct_version(2);
const AV1_GUID: nv::GUID = guid(
0x0a35_2289,
0x0aa7,
0x4759,
[0x86, 0x2d, 0x5d, 0x15, 0xcd, 0x16, 0xd2, 0x54],
);
const PRESET_P4_GUID: nv::GUID = guid(
0x90a7_b826,
0xdf06,
0x4862,
[0xb9, 0xd2, 0xcd, 0x6d, 0x73, 0xa0, 0x86, 0x81],
);
const fn guid(data1: u32, data2: u16, data3: u16, data4: [u8; 8]) -> nv::GUID {
nv::GUID {
Data1: data1,
Data2: data2,
Data3: data3,
Data4: data4,
}
}
fn same_guid(a: &nv::GUID, b: &nv::GUID) -> bool {
(a.Data1, a.Data2, a.Data3, a.Data4) == (b.Data1, b.Data2, b.Data3, b.Data4)
}
type Status = nv::NVENCSTATUS;
#[allow(clippy::unnecessary_cast)]
const FORCE_KEYFRAME: u32 =
(nv::NV_ENC_PIC_FLAG_FORCEIDR | nv::NV_ENC_PIC_FLAG_OUTPUT_SPSPPS) as u32;
macro_rules! call {
($fns:expr, $name:ident($($arg:expr),* $(,)?)) => {
match $fns.$name {
Some(function) => function($($arg),*),
None => nv::NV_ENC_ERR_UNIMPLEMENTED,
}
};
}
unsafe fn zeroed<T>() -> T {
unsafe { std::mem::zeroed() }
}
fn codec_error(operation: &'static str, status: Status) -> Error {
Error::Codec {
library: "NVENC",
operation,
message: format!("NVENCSTATUS {status}"),
}
}
fn check(status: Status, operation: &'static str) -> Result<()> {
if status == nv::NV_ENC_SUCCESS {
Ok(())
} else {
Err(codec_error(operation, status))
}
}
fn check_open(status: Status, step: &str) -> Result<()> {
if status == nv::NV_ENC_SUCCESS {
Ok(())
} else {
Err(ENCODER.unavailable(format!("{step} failed (NVENCSTATUS {status})")))
}
}
pub(super) fn open(
codec: Codec,
config: EncoderConfig,
probe: &mut Probe,
) -> Result<Box<dyn VideoEncoder>> {
if codec != Codec::Av1 {
probe.reason = Some(UnavailableReason::CodecNotSupported);
return Err(ENCODER.unavailable("NVENC has no VP9 encoder"));
}
validate(&config)?;
let api = Api::load(probe)?;
let device = Device::Cuda(Cuda::open(probe)?);
Ok(Box::new(NvencEncoder::new(api, device, config, probe)?))
}
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(MAX_LAYERS)
}
fn validate_bitrate(bitrate_kbps: u32) -> Result<()> {
if bitrate_kbps == 0 {
return Err(Error::InvalidConfig("bitrate 0".into()));
}
Ok(())
}
fn check_driver_version(status: Status, version: u32, probe: &mut Probe) -> Result<()> {
check_open(status, "reading the NVENC API version")?;
probe.driver_version = Some(format!("NVENC API {}.{}", version >> 4, version & 0xf));
let required = (nv::NVENCAPI_MAJOR_VERSION << 4) | nv::NVENCAPI_MINOR_VERSION;
if version < required {
probe.reason = Some(UnavailableReason::DriverTooOld);
return Err(ENCODER.unavailable(format!(
"the driver offers NVENC API {}.{}; AV1 temporal layers need {}.{} (driver 570 or newer)",
version >> 4,
version & 0xf,
nv::NVENCAPI_MAJOR_VERSION,
nv::NVENCAPI_MINOR_VERSION
)));
}
Ok(())
}
struct Api {
fns: nv::NV_ENCODE_API_FUNCTION_LIST,
_library: Option<Library>,
}
impl Api {
fn load(probe: &mut Probe) -> Result<Self> {
type GetMaxSupportedVersion = unsafe extern "C" fn(*mut u32) -> Status;
type CreateInstance = unsafe extern "C" fn(*mut nv::NV_ENCODE_API_FUNCTION_LIST) -> Status;
let library = dl::open(ENCODER, dl::NVENC, probe)?;
let (max_version, create_instance) = unsafe {
(
dl::symbol::<GetMaxSupportedVersion>(
ENCODER,
&library,
"NvEncodeAPIGetMaxSupportedVersion",
)?,
dl::symbol::<CreateInstance>(ENCODER, &library, "NvEncodeAPICreateInstance")?,
)
};
let mut version = 0;
let status = unsafe { max_version(&mut version) };
check_driver_version(status, version, probe)?;
let mut fns: nv::NV_ENCODE_API_FUNCTION_LIST = unsafe { zeroed() };
fns.version = FUNCTION_LIST_VER;
check_open(
unsafe { create_instance(&mut fns) },
"NvEncodeAPICreateInstance",
)?;
Self::new(fns, Some(library))
}
fn new(fns: nv::NV_ENCODE_API_FUNCTION_LIST, library: Option<Library>) -> Result<Self> {
let required = [
(
"nvEncOpenEncodeSessionEx",
fns.nvEncOpenEncodeSessionEx.is_some(),
),
(
"nvEncGetEncodeGUIDCount",
fns.nvEncGetEncodeGUIDCount.is_some(),
),
("nvEncGetEncodeGUIDs", fns.nvEncGetEncodeGUIDs.is_some()),
("nvEncGetEncodeCaps", fns.nvEncGetEncodeCaps.is_some()),
(
"nvEncGetEncodePresetConfigEx",
fns.nvEncGetEncodePresetConfigEx.is_some(),
),
(
"nvEncInitializeEncoder",
fns.nvEncInitializeEncoder.is_some(),
),
(
"nvEncReconfigureEncoder",
fns.nvEncReconfigureEncoder.is_some(),
),
(
"nvEncCreateInputBuffer",
fns.nvEncCreateInputBuffer.is_some(),
),
(
"nvEncDestroyInputBuffer",
fns.nvEncDestroyInputBuffer.is_some(),
),
("nvEncLockInputBuffer", fns.nvEncLockInputBuffer.is_some()),
(
"nvEncUnlockInputBuffer",
fns.nvEncUnlockInputBuffer.is_some(),
),
(
"nvEncCreateBitstreamBuffer",
fns.nvEncCreateBitstreamBuffer.is_some(),
),
(
"nvEncDestroyBitstreamBuffer",
fns.nvEncDestroyBitstreamBuffer.is_some(),
),
("nvEncEncodePicture", fns.nvEncEncodePicture.is_some()),
("nvEncLockBitstream", fns.nvEncLockBitstream.is_some()),
("nvEncUnlockBitstream", fns.nvEncUnlockBitstream.is_some()),
("nvEncDestroyEncoder", fns.nvEncDestroyEncoder.is_some()),
];
if let Some((name, _)) = required.iter().find(|(_, present)| !present) {
return Err(ENCODER.unavailable(format!("driver lacks {name}")));
}
Ok(Self {
fns,
_library: library,
})
}
}
type CuResult = c_int;
type CuDevice = c_int;
type CuContext = *mut c_void;
struct Cuda {
context: CuContext,
push: unsafe extern "C" fn(CuContext) -> CuResult,
pop: unsafe extern "C" fn(*mut CuContext) -> CuResult,
destroy: unsafe extern "C" fn(CuContext) -> CuResult,
_library: Library,
}
impl Cuda {
fn open(probe: &mut Probe) -> Result<Self> {
let library = dl::open(ENCODER, CUDA, probe)?;
let (init, device_get, create, destroy, push, pop) = unsafe {
(
dl::symbol::<unsafe extern "C" fn(c_uint) -> CuResult>(
ENCODER, &library, "cuInit",
)?,
dl::symbol::<unsafe extern "C" fn(*mut CuDevice, c_int) -> CuResult>(
ENCODER,
&library,
"cuDeviceGet",
)?,
dl::symbol::<unsafe extern "C" fn(*mut CuContext, c_uint, CuDevice) -> CuResult>(
ENCODER,
&library,
"cuCtxCreate_v2",
)?,
dl::symbol::<unsafe extern "C" fn(CuContext) -> CuResult>(
ENCODER,
&library,
"cuCtxDestroy_v2",
)?,
dl::symbol::<unsafe extern "C" fn(CuContext) -> CuResult>(
ENCODER,
&library,
"cuCtxPushCurrent_v2",
)?,
dl::symbol::<unsafe extern "C" fn(*mut CuContext) -> CuResult>(
ENCODER,
&library,
"cuCtxPopCurrent_v2",
)?,
)
};
let cuda_check = |result: CuResult, step: &str| {
if result == 0 {
Ok(())
} else {
Err(ENCODER.unavailable(format!("CUDA {step} failed (CUresult {result})")))
}
};
let mut device = 0;
let mut context = ptr::null_mut();
unsafe {
cuda_check(init(0), "cuInit")?;
cuda_check(device_get(&mut device, 0), "cuDeviceGet")?;
cuda_check(create(&mut context, 0, device), "cuCtxCreate")?;
}
let get_name = unsafe { dl::symbol::<DeviceGetName>(ENCODER, &library, "cuDeviceGetName") };
if let Ok(get_name) = get_name {
probe.device = device_name(get_name, device);
}
let cuda = Self {
context,
push,
pop,
destroy,
_library: library,
};
let mut popped = ptr::null_mut();
cuda_check(unsafe { (cuda.pop)(&mut popped) }, "cuCtxPopCurrent")?;
Ok(cuda)
}
}
type DeviceGetName = unsafe extern "C" fn(*mut c_char, c_int, CuDevice) -> CuResult;
fn device_name(get_name: DeviceGetName, device: CuDevice) -> Option<String> {
let mut name = [0; 256];
let result = unsafe { get_name(name.as_mut_ptr(), name.len() as c_int - 1, device) };
if result != 0 {
return None;
}
let name = unsafe { CStr::from_ptr(name.as_ptr()) }.to_string_lossy();
let name = name.trim();
(!name.is_empty()).then(|| name.to_owned())
}
impl Drop for Cuda {
fn drop(&mut self) {
unsafe { (self.destroy)(self.context) };
}
}
enum Device {
Cuda(Cuda),
#[cfg(test)]
Mock,
}
impl Device {
fn handle(&self) -> *mut c_void {
match self {
Self::Cuda(cuda) => cuda.context,
#[cfg(test)]
Self::Mock => ptr::NonNull::<u8>::dangling().as_ptr().cast(),
}
}
fn cuda(&self) -> Option<&Cuda> {
match self {
Self::Cuda(cuda) => Some(cuda),
#[cfg(test)]
Self::Mock => None,
}
}
fn enter(&self) -> Result<Current<'_>> {
if let Some(cuda) = self.cuda() {
let result = unsafe { (cuda.push)(cuda.context) };
if result != 0 {
return Err(Error::Codec {
library: "CUDA",
operation: "make the context current",
message: format!("CUresult {result}"),
});
}
}
Ok(Current(self))
}
}
struct Current<'a>(&'a Device);
impl Drop for Current<'_> {
fn drop(&mut self) {
if let Some(cuda) = self.0.cuda() {
let mut popped = ptr::null_mut();
unsafe { (cuda.pop)(&mut popped) };
}
}
}
struct Session {
encoder: *mut c_void,
input: nv::NV_ENC_INPUT_PTR,
output: nv::NV_ENC_OUTPUT_PTR,
config: Box<nv::NV_ENC_CONFIG>,
init: Box<nv::NV_ENC_INITIALIZE_PARAMS>,
max_layers: u8,
}
impl Session {
fn open(
api: &Api,
device: &Device,
config: &EncoderConfig,
layers: u8,
probe: &mut Probe,
) -> Result<Self> {
let mut params: nv::NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS = unsafe { zeroed() };
params.version = OPEN_SESSION_VER;
params.deviceType = nv::NV_ENC_DEVICE_TYPE_CUDA;
params.device = device.handle();
params.apiVersion = nv::NVENCAPI_VERSION;
let mut encoder = ptr::null_mut();
let status = unsafe { call!(api.fns, nvEncOpenEncodeSessionEx(&mut params, &mut encoder)) };
let mut session = Self {
encoder,
input: ptr::null_mut(),
output: ptr::null_mut(),
config: Box::new(unsafe { zeroed() }),
init: Box::new(unsafe { zeroed() }),
max_layers: 1,
};
let opened = check_open(status, "opening an NVENC session")
.and_then(|()| session.configure(api, config, layers, probe));
match opened {
Ok(()) => Ok(session),
Err(err) => {
session.close(api);
Err(err)
}
}
}
fn configure(
&mut self,
api: &Api,
config: &EncoderConfig,
layers: u8,
probe: &mut Probe,
) -> Result<()> {
self.check_av1(api, probe)?;
let max_width = self.caps(api, nv::NV_ENC_CAPS_WIDTH_MAX)?;
let max_height = self.caps(api, nv::NV_ENC_CAPS_HEIGHT_MAX)?;
if i64::from(config.width) > i64::from(max_width)
|| i64::from(config.height) > i64::from(max_height)
{
return Err(ENCODER.unavailable(format!(
"{}x{} is larger than this GPU's AV1 limit of {max_width}x{max_height}",
config.width, config.height
)));
}
self.max_layers = if self.caps(api, nv::NV_ENC_CAPS_SUPPORT_TEMPORAL_SVC)? == 0 {
1
} else {
let max = self.caps(api, nv::NV_ENC_CAPS_NUM_MAX_TEMPORAL_LAYERS)?;
u8::try_from(max.clamp(1, i32::from(MAX_LAYERS))).unwrap_or(1)
};
if let Some(requested) = config.temporal_layers
&& requested > self.max_layers
{
return Err(Error::InvalidConfig(format!(
"{requested} temporal layers (this GPU produces at most {})",
self.max_layers
)));
}
let mut preset: nv::NV_ENC_PRESET_CONFIG = unsafe { zeroed() };
preset.version = PRESET_CONFIG_VER;
preset.presetCfg.version = CONFIG_VER;
check_open(
unsafe {
call!(
api.fns,
nvEncGetEncodePresetConfigEx(
self.encoder,
AV1_GUID,
PRESET_P4_GUID,
nv::NV_ENC_TUNING_INFO_ULTRA_LOW_LATENCY,
&mut preset,
)
)
},
"reading the AV1 preset",
)?;
*self.config = preset.presetCfg;
let cfg = &mut *self.config;
cfg.version = CONFIG_VER;
cfg.gopLength = nv::NVENC_INFINITE_GOPLENGTH;
cfg.frameIntervalP = 1;
cfg.rcParams.rateControlMode = nv::NV_ENC_PARAMS_RC_CBR;
set_rate(cfg, config);
let av1 = unsafe { &mut cfg.encodeCodecConfig.av1Config };
av1.idrPeriod = nv::NVENC_INFINITE_GOPLENGTH;
av1.set_repeatSeqHdr(1);
av1.set_chromaFormatIDC(1);
if self.max_layers > 1 {
av1.set_enableTemporalSVC(1);
av1.maxTemporalLayersMinus1 = u32::from(self.max_layers - 1);
av1.numTemporalLayers = u32::from(layers.min(self.max_layers));
}
let init = &mut *self.init;
init.version = INITIALIZE_PARAMS_VER;
init.encodeGUID = AV1_GUID;
init.presetGUID = PRESET_P4_GUID;
init.tuningInfo = nv::NV_ENC_TUNING_INFO_ULTRA_LOW_LATENCY;
init.encodeWidth = config.width;
init.encodeHeight = config.height;
init.darWidth = config.width;
init.darHeight = config.height;
init.maxEncodeWidth = config.width;
init.maxEncodeHeight = config.height;
init.frameRateNum = config.fps;
init.frameRateDen = 1;
init.enableEncodeAsync = 0;
init.enablePTD = 1;
init.encodeConfig = &mut *self.config;
check_open(
unsafe {
call!(
api.fns,
nvEncInitializeEncoder(self.encoder, &mut *self.init)
)
},
"initialising the AV1 encoder",
)?;
let mut input: nv::NV_ENC_CREATE_INPUT_BUFFER = unsafe { zeroed() };
input.version = CREATE_INPUT_BUFFER_VER;
input.width = config.width;
input.height = config.height;
input.bufferFmt = nv::NV_ENC_BUFFER_FORMAT_IYUV;
check_open(
unsafe { call!(api.fns, nvEncCreateInputBuffer(self.encoder, &mut input)) },
"creating the input buffer",
)?;
self.input = input.inputBuffer;
let mut output: nv::NV_ENC_CREATE_BITSTREAM_BUFFER = unsafe { zeroed() };
output.version = CREATE_BITSTREAM_BUFFER_VER;
check_open(
unsafe {
call!(
api.fns,
nvEncCreateBitstreamBuffer(self.encoder, &mut output)
)
},
"creating the output buffer",
)?;
self.output = output.bitstreamBuffer;
Ok(())
}
fn check_av1(&self, api: &Api, probe: &mut Probe) -> Result<()> {
let mut count = 0;
check_open(
unsafe { call!(api.fns, nvEncGetEncodeGUIDCount(self.encoder, &mut count)) },
"listing the codecs",
)?;
let mut guids = vec![guid(0, 0, 0, [0; 8]); count as usize];
let mut written = 0;
check_open(
unsafe {
call!(
api.fns,
nvEncGetEncodeGUIDs(self.encoder, guids.as_mut_ptr(), count, &mut written)
)
},
"listing the codecs",
)?;
guids.truncate(written as usize);
if guids.iter().any(|g| same_guid(g, &AV1_GUID)) {
Ok(())
} else {
probe.reason = Some(UnavailableReason::CodecNotSupported);
Err(ENCODER.unavailable("this GPU has no AV1 encoder (GeForce RTX 40 or newer)"))
}
}
fn caps(&self, api: &Api, cap: nv::NV_ENC_CAPS) -> Result<i32> {
let mut param: nv::NV_ENC_CAPS_PARAM = unsafe { zeroed() };
param.version = CAPS_PARAM_VER;
param.capsToQuery = cap;
let mut value = 0;
check_open(
unsafe {
call!(
api.fns,
nvEncGetEncodeCaps(self.encoder, AV1_GUID, &mut param, &mut value)
)
},
"reading the AV1 capabilities",
)?;
Ok(value)
}
fn close(&mut self, api: &Api) {
if self.encoder.is_null() {
return;
}
unsafe {
if !self.input.is_null() {
call!(api.fns, nvEncDestroyInputBuffer(self.encoder, self.input));
}
if !self.output.is_null() {
call!(
api.fns,
nvEncDestroyBitstreamBuffer(self.encoder, self.output)
);
}
call!(api.fns, nvEncDestroyEncoder(self.encoder));
}
self.encoder = ptr::null_mut();
self.input = ptr::null_mut();
self.output = ptr::null_mut();
}
}
fn set_rate(cfg: &mut nv::NV_ENC_CONFIG, config: &EncoderConfig) {
let bitrate = config.bitrate_kbps.saturating_mul(1000);
let rc = &mut cfg.rcParams;
rc.averageBitRate = bitrate;
rc.maxBitRate = bitrate;
rc.vbvBufferSize = bitrate / config.fps;
rc.vbvInitialDelay = rc.vbvBufferSize;
}
struct NvencEncoder {
session: Session,
config: EncoderConfig,
layers: u8,
layers_changed: bool,
frame_index: u32,
device: Device,
api: Api,
}
unsafe impl Send for NvencEncoder {}
impl NvencEncoder {
fn new(api: Api, device: Device, config: EncoderConfig, probe: &mut Probe) -> Result<Self> {
let session = {
let _current = device.enter()?;
Session::open(&api, &device, &config, config_layers(&config), probe)?
};
Ok(Self {
layers: config_layers(&config).min(session.max_layers),
session,
config,
layers_changed: false,
frame_index: 0,
device,
api,
})
}
fn upload(&self, frame: &I420Frame) -> Result<u32> {
let mut lock: nv::NV_ENC_LOCK_INPUT_BUFFER = unsafe { zeroed() };
lock.version = LOCK_INPUT_BUFFER_VER;
lock.inputBuffer = self.session.input;
check(
unsafe {
call!(
self.api.fns,
nvEncLockInputBuffer(self.session.encoder, &mut lock)
)
},
"lock the input buffer",
)?;
let copied = copy_iyuv(frame, lock.bufferDataPtr.cast(), lock.pitch);
let unlocked = unsafe {
call!(
self.api.fns,
nvEncUnlockInputBuffer(self.session.encoder, self.session.input)
)
};
copied?;
check(unlocked, "unlock the input buffer")?;
Ok(lock.pitch)
}
fn download(&self, pts: i64) -> Result<EncodedFrame> {
let mut lock: nv::NV_ENC_LOCK_BITSTREAM = unsafe { zeroed() };
lock.version = LOCK_BITSTREAM_VER;
lock.outputBitstream = self.session.output;
check(
unsafe {
call!(
self.api.fns,
nvEncLockBitstream(self.session.encoder, &mut lock)
)
},
"lock the output buffer",
)?;
let data = unsafe {
std::slice::from_raw_parts(
lock.bitstreamBufferPtr.cast::<u8>(),
lock.bitstreamSizeInBytes as usize,
)
}
.to_vec();
check(
unsafe {
call!(
self.api.fns,
nvEncUnlockBitstream(self.session.encoder, self.session.output)
)
},
"unlock the output buffer",
)?;
let keyframe = matches!(
lock.pictureType,
nv::NV_ENC_PIC_TYPE_IDR | nv::NV_ENC_PIC_TYPE_I
);
let temporal_layer = if keyframe {
0
} else {
u8::try_from(lock.temporalId)
.ok()
.filter(|layer| *layer < self.layers)
.ok_or_else(|| Error::Codec {
library: "NVENC",
operation: "read temporal layer id",
message: format!("unexpected layer id {}", lock.temporalId),
})?
};
Ok(EncodedFrame {
data,
keyframe,
temporal_layer,
pts,
})
}
fn reconfigure(&mut self, operation: &'static str) -> Result<()> {
let _current = self.device.enter()?;
self.session.init.encodeConfig = &mut *self.session.config;
let mut params: nv::NV_ENC_RECONFIGURE_PARAMS = unsafe { zeroed() };
params.version = RECONFIGURE_PARAMS_VER;
params.reInitEncodeParams = *self.session.init;
check(
unsafe {
call!(
self.api.fns,
nvEncReconfigureEncoder(self.session.encoder, &mut params)
)
},
operation,
)
}
fn change(
&mut self,
operation: &'static str,
change: impl FnOnce(&mut EncoderConfig),
) -> Result<()> {
let previous = (self.config, *self.session.config, *self.session.init);
change(&mut self.config);
self.session.init.frameRateNum = self.config.fps;
set_rate(&mut self.session.config, &self.config);
let result = self.reconfigure(operation);
if result.is_err() {
(self.config, *self.session.config, *self.session.init) = previous;
self.session.init.encodeConfig = &mut *self.session.config;
}
result
}
}
fn copy_iyuv(frame: &I420Frame, buffer: *mut u8, pitch: u32) -> Result<()> {
let (width, height) = (frame.width() as usize, frame.height() as usize);
let pitch = pitch as usize;
if buffer.is_null() || pitch < width {
return Err(Error::Codec {
library: "NVENC",
operation: "lock the input buffer",
message: format!("unusable buffer (pitch {pitch} for width {width})"),
});
}
let (chroma_width, chroma_height) = (width.div_ceil(2), height.div_ceil(2));
let chroma_pitch = pitch.div_ceil(2);
let u_offset = pitch * height;
let v_offset = u_offset + chroma_pitch * chroma_height;
let planes = [
(frame.y(), width, height, 0, pitch),
(
frame.u(),
chroma_width,
chroma_height,
u_offset,
chroma_pitch,
),
(
frame.v(),
chroma_width,
chroma_height,
v_offset,
chroma_pitch,
),
];
for (plane, row_len, rows, offset, row_pitch) in planes {
for (row, source) in plane.chunks_exact(row_len).take(rows).enumerate() {
unsafe {
ptr::copy_nonoverlapping(
source.as_ptr(),
buffer.add(offset + row * row_pitch),
row_len,
);
}
}
}
Ok(())
}
impl Drop for NvencEncoder {
fn drop(&mut self) {
if let Ok(_current) = self.device.enter() {
self.session.close(&self.api);
}
}
}
impl VideoEncoder for NvencEncoder {
fn codec(&self) -> Codec {
Codec::Av1
}
fn config(&self) -> EncoderConfig {
self.config
}
fn temporal_layers(&self) -> u8 {
self.layers
}
fn encode(
&mut self,
frame: &I420Frame,
pts: i64,
force_keyframe: bool,
) -> Result<Vec<EncodedFrame>> {
if frame.width() != self.config.width || frame.height() != self.config.height {
return Err(Error::InvalidFrame(format!(
"{}x{} frame for a {}x{} encoder",
frame.width(),
frame.height(),
self.config.width,
self.config.height
)));
}
let _current = self.device.enter()?;
let pitch = self.upload(frame)?;
let mut pic: nv::NV_ENC_PIC_PARAMS = unsafe { zeroed() };
pic.version = PIC_PARAMS_VER;
pic.inputWidth = self.config.width;
pic.inputHeight = self.config.height;
pic.inputPitch = pitch;
pic.inputBuffer = self.session.input;
pic.outputBitstream = self.session.output;
pic.bufferFmt = nv::NV_ENC_BUFFER_FORMAT_IYUV;
pic.pictureStruct = nv::NV_ENC_PIC_STRUCT_FRAME;
pic.frameIdx = self.frame_index;
pic.inputTimeStamp = u64::from(self.frame_index);
if force_keyframe {
pic.encodePicFlags = FORCE_KEYFRAME;
}
if self.layers_changed {
let av1 = unsafe { &mut pic.codecPicParams.av1PicParams };
av1.set_temporalConfigUpdate(1);
av1.numTemporalLayers = u32::from(self.layers);
}
let status = unsafe {
call!(
self.api.fns,
nvEncEncodePicture(self.session.encoder, &mut pic)
)
};
if status == nv::NV_ENC_ERR_NEED_MORE_INPUT {
return Ok(Vec::new());
}
check(status, "encode")?;
self.layers_changed = false;
self.frame_index = self.frame_index.wrapping_add(1);
Ok(vec![self.download(pts)?])
}
fn set_resolution(&mut self, width: u32, height: u32) -> Result<()> {
let config = EncoderConfig {
width,
height,
..self.config
};
validate(&config)?;
if (width, height) == (self.config.width, self.config.height) {
return Ok(());
}
{
let _current = self.device.enter()?;
let mut session = Session::open(
&self.api,
&self.device,
&config,
self.layers,
&mut Probe::default(),
)?;
std::mem::swap(&mut self.session, &mut session);
session.close(&self.api);
}
self.config = config;
self.frame_index = 0;
self.layers_changed = false;
Ok(())
}
fn set_bitrate(&mut self, bitrate_kbps: u32) -> Result<()> {
validate_bitrate(bitrate_kbps)?;
self.change("set bitrate", |config| config.bitrate_kbps = bitrate_kbps)
}
fn set_fps(&mut self, fps: u32) -> Result<()> {
validate(&EncoderConfig { fps, ..self.config })?;
self.change("set frame rate", |config| config.fps = fps)?;
let layers = config_layers(&self.config).min(self.session.max_layers);
if layers != self.layers {
self.layers = layers;
self.layers_changed = true;
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use std::cell::RefCell;
use super::*;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Call {
Open,
Init,
Reconfigure,
CreateInput,
CreateOutput,
Encode,
DestroyInput,
DestroyOutput,
DestroyEncoder,
}
struct Picture {
flags: u32,
pitch: u32,
layer_update: Option<u32>,
}
struct Mock {
has_av1: bool,
svc: i32,
max_layers: i32,
max_size: i32,
fail_encode: bool,
fail_reconfigure: bool,
calls: Vec<Call>,
configs: Vec<(nv::NV_ENC_INITIALIZE_PARAMS, nv::NV_ENC_CONFIG)>,
pitch: u32,
input: Vec<u8>,
pictures: Vec<Picture>,
layers: u32,
since_keyframe: u32,
output: Vec<u8>,
picture_type: nv::NV_ENC_PIC_TYPE,
temporal_id: u32,
}
impl Default for Mock {
fn default() -> Self {
Self {
has_av1: true,
svc: 1,
max_layers: 4,
max_size: 4096,
fail_encode: false,
fail_reconfigure: false,
calls: Vec::new(),
configs: Vec::new(),
pitch: 0,
input: Vec::new(),
pictures: Vec::new(),
layers: 1,
since_keyframe: 0,
output: Vec::new(),
picture_type: nv::NV_ENC_PIC_TYPE_P,
temporal_id: 0,
}
}
}
thread_local! {
static MOCK: RefCell<Mock> = RefCell::new(Mock::default());
}
fn mock<R>(f: impl FnOnce(&mut Mock) -> R) -> R {
MOCK.with(|mock| f(&mut mock.borrow_mut()))
}
fn calls() -> Vec<Call> {
mock(|m| m.calls.clone())
}
const INPUT: nv::NV_ENC_INPUT_PTR = 0x10 as nv::NV_ENC_INPUT_PTR;
const OUTPUT: nv::NV_ENC_OUTPUT_PTR = 0x20 as nv::NV_ENC_OUTPUT_PTR;
const H264_GUID: nv::GUID = guid(1, 2, 3, [4; 8]);
unsafe extern "C" fn open_session(
params: *mut nv::NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS,
encoder: *mut *mut c_void,
) -> Status {
let params = unsafe { &*params };
assert_eq!(params.version, OPEN_SESSION_VER);
assert_eq!(params.deviceType, nv::NV_ENC_DEVICE_TYPE_CUDA);
assert_eq!(params.apiVersion, nv::NVENCAPI_VERSION);
assert!(!params.device.is_null());
unsafe { *encoder = ptr::NonNull::<u8>::dangling().as_ptr().cast() };
mock(|m| m.calls.push(Call::Open));
nv::NV_ENC_SUCCESS
}
unsafe extern "C" fn guid_count(_: *mut c_void, count: *mut u32) -> Status {
unsafe { *count = if mock(|m| m.has_av1) { 2 } else { 1 } };
nv::NV_ENC_SUCCESS
}
unsafe extern "C" fn guids(
_: *mut c_void,
guids: *mut nv::GUID,
size: u32,
written: *mut u32,
) -> Status {
let list: &[nv::GUID] = if mock(|m| m.has_av1) {
&[H264_GUID, AV1_GUID]
} else {
&[H264_GUID]
};
assert!(size as usize >= list.len());
unsafe {
ptr::copy_nonoverlapping(list.as_ptr(), guids, list.len());
*written = list.len() as u32;
}
nv::NV_ENC_SUCCESS
}
unsafe extern "C" fn caps(
_: *mut c_void,
codec: nv::GUID,
param: *mut nv::NV_ENC_CAPS_PARAM,
value: *mut c_int,
) -> Status {
assert!(same_guid(&codec, &AV1_GUID));
let param = unsafe { &*param };
assert_eq!(param.version, CAPS_PARAM_VER);
let answer = mock(|m| match param.capsToQuery {
nv::NV_ENC_CAPS_WIDTH_MAX | nv::NV_ENC_CAPS_HEIGHT_MAX => m.max_size,
nv::NV_ENC_CAPS_SUPPORT_TEMPORAL_SVC => m.svc,
nv::NV_ENC_CAPS_NUM_MAX_TEMPORAL_LAYERS => m.max_layers,
other => panic!("unexpected caps query {other}"),
});
unsafe { *value = answer };
nv::NV_ENC_SUCCESS
}
unsafe extern "C" fn preset(
_: *mut c_void,
codec: nv::GUID,
preset: nv::GUID,
tuning: nv::NV_ENC_TUNING_INFO,
config: *mut nv::NV_ENC_PRESET_CONFIG,
) -> Status {
assert!(same_guid(&codec, &AV1_GUID));
assert!(same_guid(&preset, &PRESET_P4_GUID));
assert_eq!(tuning, nv::NV_ENC_TUNING_INFO_ULTRA_LOW_LATENCY);
let config = unsafe { &mut *config };
assert_eq!(config.version, PRESET_CONFIG_VER);
assert_eq!(config.presetCfg.version, CONFIG_VER);
config.presetCfg.gopLength = 250;
config.presetCfg.frameIntervalP = 3;
nv::NV_ENC_SUCCESS
}
fn record(init: &nv::NV_ENC_INITIALIZE_PARAMS, m: &mut Mock) {
let config = unsafe { *init.encodeConfig };
m.configs.push((*init, config));
}
unsafe extern "C" fn initialize(
_: *mut c_void,
init: *mut nv::NV_ENC_INITIALIZE_PARAMS,
) -> Status {
let init = unsafe { &*init };
assert_eq!(init.version, INITIALIZE_PARAMS_VER);
let av1 = unsafe { (*init.encodeConfig).encodeCodecConfig.av1Config };
mock(|m| {
record(init, m);
m.calls.push(Call::Init);
m.layers = av1.numTemporalLayers.max(1);
m.since_keyframe = 0;
m.pitch = init.encodeWidth.next_multiple_of(64);
let rows = init.encodeHeight as usize;
let pitch = m.pitch as usize;
m.input = vec![0; pitch * rows + 2 * pitch.div_ceil(2) * rows.div_ceil(2)];
});
nv::NV_ENC_SUCCESS
}
unsafe extern "C" fn reconfigure(
_: *mut c_void,
params: *mut nv::NV_ENC_RECONFIGURE_PARAMS,
) -> Status {
let params = unsafe { &*params };
assert_eq!(params.version, RECONFIGURE_PARAMS_VER);
assert_eq!(params.resetEncoder(), 0);
assert_eq!(params.forceIDR(), 0);
mock(|m| {
m.calls.push(Call::Reconfigure);
if m.fail_reconfigure {
return nv::NV_ENC_ERR_INVALID_PARAM;
}
record(¶ms.reInitEncodeParams, m);
nv::NV_ENC_SUCCESS
})
}
unsafe extern "C" fn create_input(
_: *mut c_void,
params: *mut nv::NV_ENC_CREATE_INPUT_BUFFER,
) -> Status {
let params = unsafe { &mut *params };
assert_eq!(params.version, CREATE_INPUT_BUFFER_VER);
assert_eq!(params.bufferFmt, nv::NV_ENC_BUFFER_FORMAT_IYUV);
params.inputBuffer = INPUT;
mock(|m| m.calls.push(Call::CreateInput));
nv::NV_ENC_SUCCESS
}
unsafe extern "C" fn lock_input(
_: *mut c_void,
params: *mut nv::NV_ENC_LOCK_INPUT_BUFFER,
) -> Status {
let params = unsafe { &mut *params };
assert_eq!(params.version, LOCK_INPUT_BUFFER_VER);
assert_eq!(params.inputBuffer, INPUT);
mock(|m| {
params.bufferDataPtr = m.input.as_mut_ptr().cast();
params.pitch = m.pitch;
});
nv::NV_ENC_SUCCESS
}
unsafe extern "C" fn unlock_input(_: *mut c_void, input: nv::NV_ENC_INPUT_PTR) -> Status {
assert_eq!(input, INPUT);
nv::NV_ENC_SUCCESS
}
unsafe extern "C" fn create_output(
_: *mut c_void,
params: *mut nv::NV_ENC_CREATE_BITSTREAM_BUFFER,
) -> Status {
let params = unsafe { &mut *params };
assert_eq!(params.version, CREATE_BITSTREAM_BUFFER_VER);
params.bitstreamBuffer = OUTPUT;
mock(|m| m.calls.push(Call::CreateOutput));
nv::NV_ENC_SUCCESS
}
unsafe extern "C" fn encode(_: *mut c_void, pic: *mut nv::NV_ENC_PIC_PARAMS) -> Status {
let pic = unsafe { &*pic };
assert_eq!(pic.version, PIC_PARAMS_VER);
assert_eq!((pic.inputBuffer, pic.outputBitstream), (INPUT, OUTPUT));
assert_eq!(pic.bufferFmt, nv::NV_ENC_BUFFER_FORMAT_IYUV);
let av1 = unsafe { pic.codecPicParams.av1PicParams };
mock(|m| {
m.calls.push(Call::Encode);
if m.fail_encode {
return nv::NV_ENC_ERR_GENERIC;
}
let layer_update = (av1.temporalConfigUpdate() == 1).then_some(av1.numTemporalLayers);
if let Some(layers) = layer_update {
m.layers = layers;
}
m.pictures.push(Picture {
flags: pic.encodePicFlags,
pitch: pic.inputPitch,
layer_update,
});
if pic.encodePicFlags & FORCE_KEYFRAME != 0 {
m.since_keyframe = 0;
}
let position = m.since_keyframe % (1 << (m.layers - 1));
m.temporal_id = if position == 0 {
0
} else {
m.layers - 1 - position.trailing_zeros()
};
m.picture_type = if m.since_keyframe == 0 {
nv::NV_ENC_PIC_TYPE_IDR
} else {
nv::NV_ENC_PIC_TYPE_P
};
m.output = vec![pic.frameIdx as u8, m.temporal_id as u8];
m.since_keyframe += 1;
nv::NV_ENC_SUCCESS
})
}
unsafe extern "C" fn lock_output(
_: *mut c_void,
lock: *mut nv::NV_ENC_LOCK_BITSTREAM,
) -> Status {
let lock = unsafe { &mut *lock };
assert_eq!(lock.version, LOCK_BITSTREAM_VER);
assert_eq!(lock.outputBitstream, OUTPUT);
mock(|m| {
lock.bitstreamBufferPtr = m.output.as_mut_ptr().cast();
lock.bitstreamSizeInBytes = m.output.len() as u32;
lock.pictureType = m.picture_type;
lock.temporalId = m.temporal_id;
});
nv::NV_ENC_SUCCESS
}
unsafe extern "C" fn unlock_output(_: *mut c_void, output: nv::NV_ENC_OUTPUT_PTR) -> Status {
assert_eq!(output, OUTPUT);
nv::NV_ENC_SUCCESS
}
unsafe extern "C" fn destroy_input(_: *mut c_void, input: nv::NV_ENC_INPUT_PTR) -> Status {
assert_eq!(input, INPUT);
mock(|m| m.calls.push(Call::DestroyInput));
nv::NV_ENC_SUCCESS
}
unsafe extern "C" fn destroy_output(_: *mut c_void, output: nv::NV_ENC_OUTPUT_PTR) -> Status {
assert_eq!(output, OUTPUT);
mock(|m| m.calls.push(Call::DestroyOutput));
nv::NV_ENC_SUCCESS
}
unsafe extern "C" fn destroy_encoder(_: *mut c_void) -> Status {
mock(|m| m.calls.push(Call::DestroyEncoder));
nv::NV_ENC_SUCCESS
}
fn function_list() -> nv::NV_ENCODE_API_FUNCTION_LIST {
let mut fns: nv::NV_ENCODE_API_FUNCTION_LIST = unsafe { zeroed() };
fns.version = FUNCTION_LIST_VER;
fns.nvEncOpenEncodeSessionEx = Some(open_session);
fns.nvEncGetEncodeGUIDCount = Some(guid_count);
fns.nvEncGetEncodeGUIDs = Some(guids);
fns.nvEncGetEncodeCaps = Some(caps);
fns.nvEncGetEncodePresetConfigEx = Some(preset);
fns.nvEncInitializeEncoder = Some(initialize);
fns.nvEncReconfigureEncoder = Some(reconfigure);
fns.nvEncCreateInputBuffer = Some(create_input);
fns.nvEncDestroyInputBuffer = Some(destroy_input);
fns.nvEncLockInputBuffer = Some(lock_input);
fns.nvEncUnlockInputBuffer = Some(unlock_input);
fns.nvEncCreateBitstreamBuffer = Some(create_output);
fns.nvEncDestroyBitstreamBuffer = Some(destroy_output);
fns.nvEncEncodePicture = Some(encode);
fns.nvEncLockBitstream = Some(lock_output);
fns.nvEncUnlockBitstream = Some(unlock_output);
fns.nvEncDestroyEncoder = Some(destroy_encoder);
fns
}
fn config(width: u32, height: u32, fps: u32) -> EncoderConfig {
EncoderConfig::new(width, height, fps, 3000)
}
fn open_mock(config: EncoderConfig) -> Result<NvencEncoder> {
probe_mock(config).0
}
fn probe_mock(config: EncoderConfig) -> (Result<NvencEncoder>, Probe) {
let mut probe = Probe::default();
let opened = validate(&config).and_then(|()| {
let api = Api::new(function_list(), None)?;
NvencEncoder::new(api, Device::Mock, config, &mut probe)
});
(opened, probe)
}
fn last_config() -> (nv::NV_ENC_INITIALIZE_PARAMS, nv::NV_ENC_CONFIG) {
mock(|m| *m.configs.last().expect("a configuration"))
}
fn av1(config: &nv::NV_ENC_CONFIG) -> nv::NV_ENC_CONFIG_AV1 {
unsafe { config.encodeCodecConfig.av1Config }
}
fn frame(width: u32, height: u32) -> I420Frame {
let luma = (width * height) as usize;
let chroma = (I420Frame::buffer_len(width, height) - luma) / 2;
let mut data: Vec<u8> = (0..luma).map(|i| (i % 199) as u8).collect();
data.extend(std::iter::repeat_n(200, chroma));
data.extend(std::iter::repeat_n(250, chroma));
I420Frame::new(width, height, data).expect("frame")
}
#[test]
fn opens_a_low_latency_cbr_av1_session_with_three_layers_at_30_fps() {
let encoder = open_mock(config(1920, 1080, 30)).expect("encoder");
assert_eq!(encoder.codec(), Codec::Av1);
assert_eq!(encoder.temporal_layers(), 3);
let (init, cfg) = last_config();
assert!(same_guid(&init.encodeGUID, &AV1_GUID));
assert!(same_guid(&init.presetGUID, &PRESET_P4_GUID));
assert_eq!(init.tuningInfo, nv::NV_ENC_TUNING_INFO_ULTRA_LOW_LATENCY);
assert_eq!((init.encodeWidth, init.encodeHeight), (1920, 1080));
assert_eq!((init.frameRateNum, init.frameRateDen), (30, 1));
assert_eq!((init.enablePTD, init.enableEncodeAsync), (1, 0));
assert_eq!(cfg.version, CONFIG_VER);
assert_eq!(cfg.gopLength, nv::NVENC_INFINITE_GOPLENGTH);
assert_eq!(cfg.frameIntervalP, 1);
assert_eq!(cfg.rcParams.rateControlMode, nv::NV_ENC_PARAMS_RC_CBR);
assert_eq!(cfg.rcParams.averageBitRate, 3_000_000);
assert_eq!(cfg.rcParams.maxBitRate, 3_000_000);
assert_eq!(cfg.rcParams.vbvBufferSize, 100_000);
let av1 = av1(&cfg);
assert_eq!(av1.idrPeriod, nv::NVENC_INFINITE_GOPLENGTH);
assert_eq!(av1.repeatSeqHdr(), 1);
assert_eq!(av1.chromaFormatIDC(), 1);
assert_eq!(av1.enableTemporalSVC(), 1);
assert_eq!(av1.maxTemporalLayersMinus1, 3);
assert_eq!(av1.numTemporalLayers, 3);
assert_eq!(
calls(),
[
Call::Open,
Call::Init,
Call::CreateInput,
Call::CreateOutput
]
);
}
#[test]
fn four_layers_only_from_60_fps() {
assert_eq!(
[15, 30, 45, 59, 60].map(wanted_layers),
[3, 3, 3, 3, MAX_LAYERS]
);
}
#[test]
fn uses_four_layers_at_60_fps() {
let encoder = open_mock(config(1920, 1080, 60)).expect("encoder");
assert_eq!(encoder.temporal_layers(), 4);
assert_eq!(av1(&last_config().1).numTemporalLayers, 4);
}
#[test]
fn a_gpu_without_temporal_svc_streams_a_single_layer() {
mock(|m| m.svc = 0);
let encoder = open_mock(config(1280, 720, 60)).expect("encoder");
assert_eq!(encoder.temporal_layers(), 1);
let av1 = av1(&last_config().1);
assert_eq!(av1.enableTemporalSVC(), 0);
assert_eq!(av1.numTemporalLayers, 0);
}
#[test]
fn the_layer_count_is_capped_by_the_gpu() {
mock(|m| m.max_layers = 2);
let encoder = open_mock(config(1280, 720, 60)).expect("encoder");
assert_eq!(encoder.temporal_layers(), 2);
let av1 = av1(&last_config().1);
assert_eq!((av1.maxTemporalLayersMinus1, av1.numTemporalLayers), (1, 2));
}
#[test]
fn a_gpu_without_av1_is_unavailable_and_its_session_closed() {
mock(|m| m.has_av1 = false);
let (opened, probe) = probe_mock(config(1280, 720, 30));
assert_eq!(probe.reason, Some(UnavailableReason::CodecNotSupported));
let err = opened.err().expect("no AV1");
let Error::HardwareUnavailable { encoder, reason } = err else {
panic!("unexpected error {err}");
};
assert_eq!(encoder, HardwareEncoder::Nvenc);
assert!(reason.contains("no AV1 encoder"), "{reason}");
assert_eq!(calls(), [Call::Open, Call::DestroyEncoder]);
}
#[test]
fn a_size_beyond_the_gpu_limit_is_unavailable() {
mock(|m| m.max_size = 1024);
let err = open_mock(config(1920, 1080, 30)).err().expect("too large");
assert!(matches!(err, Error::HardwareUnavailable { .. }), "{err}");
}
#[test]
fn copies_the_i420_planes_with_the_buffer_pitch() {
let mut encoder = open_mock(config(20, 10, 30)).expect("encoder");
let frame = frame(20, 10);
encoder.encode(&frame, 0, false).expect("encode");
let (pitch, input, picture_pitch) =
mock(|m| (m.pitch as usize, m.input.clone(), m.pictures[0].pitch));
assert_eq!(pitch, 64);
assert_eq!(picture_pitch, 64);
for row in 0..10 {
assert_eq!(
&input[row * pitch..row * pitch + 20],
&frame.y()[row * 20..][..20]
);
}
let chroma_pitch = pitch / 2;
let u = pitch * 10;
let v = u + chroma_pitch * 5;
for row in 0..5 {
assert!(
input[u + row * chroma_pitch..][..10]
.iter()
.all(|&b| b == 200)
);
assert!(
input[v + row * chroma_pitch..][..10]
.iter()
.all(|&b| b == 250)
);
}
}
#[test]
fn returns_keyframes_and_temporal_layers_from_the_driver() {
let mut encoder = open_mock(config(64, 64, 30)).expect("encoder");
let frame = frame(64, 64);
let mut packets = Vec::new();
for (pts, force) in [
(0, false),
(33, false),
(67, false),
(100, false),
(133, true),
(167, false),
] {
let out = encoder.encode(&frame, pts, force).expect("encode");
assert_eq!(out.len(), 1);
packets.extend(out);
}
let summary: Vec<_> = packets
.iter()
.map(|p| (p.keyframe, p.temporal_layer, p.pts))
.collect();
assert_eq!(
summary,
[
(true, 0, 0),
(false, 2, 33),
(false, 1, 67),
(false, 2, 100),
(true, 0, 133),
(false, 2, 167)
]
);
assert_eq!(packets[1].data, [1, 2]);
let forced = mock(|m| m.pictures[4].flags);
assert_eq!(forced, FORCE_KEYFRAME);
assert_eq!(mock(|m| m.pictures[3].flags), 0);
}
#[test]
fn rejects_a_frame_of_the_wrong_size() {
let mut encoder = open_mock(config(64, 64, 30)).expect("encoder");
let err = encoder
.encode(&frame(32, 32), 0, false)
.expect_err("wrong size");
assert!(matches!(err, Error::InvalidFrame(_)), "{err}");
}
#[test]
fn a_driver_failure_while_encoding_is_a_codec_error() {
let mut encoder = open_mock(config(64, 64, 30)).expect("encoder");
mock(|m| m.fail_encode = true);
let err = encoder
.encode(&frame(64, 64), 0, false)
.expect_err("failure");
assert!(
matches!(
err,
Error::Codec {
library: "NVENC",
..
}
),
"{err}"
);
}
#[test]
fn set_bitrate_reconfigures_the_running_session() {
let mut encoder = open_mock(config(1280, 720, 30)).expect("encoder");
encoder.set_bitrate(6000).expect("bitrate");
assert_eq!(encoder.config().bitrate_kbps, 6000);
let (_, cfg) = last_config();
assert_eq!(cfg.rcParams.averageBitRate, 6_000_000);
assert_eq!(cfg.rcParams.vbvBufferSize, 200_000);
assert_eq!(calls().last(), Some(&Call::Reconfigure));
assert!(matches!(
encoder.set_bitrate(0),
Err(Error::InvalidConfig(_))
));
}
#[test]
fn a_refused_reconfiguration_keeps_the_previous_settings() {
let mut encoder = open_mock(config(1280, 720, 30)).expect("encoder");
mock(|m| m.fail_reconfigure = true);
encoder.set_bitrate(6000).expect_err("refused");
assert_eq!(encoder.config().bitrate_kbps, 3000);
assert_eq!(encoder.session.config.rcParams.averageBitRate, 3_000_000);
}
#[test]
fn going_to_60_fps_adds_the_fourth_layer_with_the_next_picture() {
let mut encoder = open_mock(config(64, 64, 30)).expect("encoder");
let frame = frame(64, 64);
encoder.encode(&frame, 0, false).expect("encode");
encoder.set_fps(60).expect("fps");
assert_eq!(encoder.temporal_layers(), 4);
let (init, cfg) = last_config();
assert_eq!(init.frameRateNum, 60);
assert_eq!(cfg.rcParams.vbvBufferSize, 50_000);
encoder.encode(&frame, 17, false).expect("encode");
encoder.encode(&frame, 33, false).expect("encode");
let updates: Vec<_> = mock(|m| m.pictures.iter().map(|p| p.layer_update).collect());
assert_eq!(updates, [None, Some(4), None]);
encoder.set_fps(30).expect("fps");
assert_eq!(encoder.temporal_layers(), 3);
}
#[test]
fn set_resolution_replaces_the_session() {
let mut encoder = open_mock(config(64, 64, 30)).expect("encoder");
encoder.encode(&frame(64, 64), 0, false).expect("encode");
encoder.set_resolution(128, 96).expect("resize");
assert_eq!((encoder.config().width, encoder.config().height), (128, 96));
let (init, _) = last_config();
assert_eq!((init.encodeWidth, init.encodeHeight), (128, 96));
let out = encoder.encode(&frame(128, 96), 33, false).expect("encode");
assert!(out[0].keyframe);
assert_eq!(
calls()[5..],
[
Call::Open,
Call::Init,
Call::CreateInput,
Call::CreateOutput,
Call::DestroyInput,
Call::DestroyOutput,
Call::DestroyEncoder,
Call::Encode
]
);
}
#[test]
fn dropping_the_encoder_frees_buffers_before_the_session() {
drop(open_mock(config(64, 64, 30)).expect("encoder"));
assert_eq!(
calls()[4..],
[
Call::DestroyInput,
Call::DestroyOutput,
Call::DestroyEncoder
]
);
}
#[test]
fn vp9_is_unavailable_without_loading_the_driver() {
let mut probe = Probe::default();
let err = open(Codec::Vp9, config(64, 64, 30), &mut probe)
.err()
.expect("no VP9");
assert!(matches!(err, Error::HardwareUnavailable { .. }), "{err}");
assert_eq!(probe.reason, Some(UnavailableReason::CodecNotSupported));
}
#[test]
fn drivers_before_api_13_are_too_old() {
let mut probe = Probe::default();
let err = check_driver_version(nv::NV_ENC_SUCCESS, (12 << 4) | 2, &mut probe)
.expect_err("too old");
let Error::HardwareUnavailable { reason, .. } = err else {
panic!("unexpected error {err}");
};
assert!(
reason.contains("12.2") && reason.contains("570"),
"{reason}"
);
assert_eq!(probe.reason, Some(UnavailableReason::DriverTooOld));
assert_eq!(probe.driver_version.as_deref(), Some("NVENC API 12.2"));
}
#[test]
fn drivers_from_api_13_pass_and_name_their_api_version() {
for (version, text) in [
(13 << 4, "NVENC API 13.0"),
((13 << 4) | 1, "NVENC API 13.1"),
] {
let mut probe = Probe::default();
check_driver_version(nv::NV_ENC_SUCCESS, version, &mut probe).expect(text);
assert_eq!(probe.reason, None);
assert_eq!(probe.driver_version.as_deref(), Some(text));
}
let mut probe = Probe::default();
assert!(check_driver_version(nv::NV_ENC_ERR_GENERIC, 13 << 4, &mut probe).is_err());
assert_eq!((probe.reason, probe.driver_version), (None, None));
}
#[test]
fn the_device_is_named_as_cuda_reports_it() {
unsafe extern "C" fn named(name: *mut c_char, len: c_int, device: CuDevice) -> CuResult {
assert_eq!(device, 3);
let text = c" NVIDIA GeForce RTX 4070 ".to_bytes_with_nul();
assert!(text.len() <= len as usize);
unsafe { ptr::copy_nonoverlapping(text.as_ptr().cast(), name, text.len()) };
0
}
unsafe extern "C" fn failing(_: *mut c_char, _: c_int, _: CuDevice) -> CuResult {
100
}
unsafe extern "C" fn unnamed(_: *mut c_char, _: c_int, _: CuDevice) -> CuResult {
0
}
assert_eq!(
device_name(named, 3).as_deref(),
Some("NVIDIA GeForce RTX 4070")
);
assert_eq!(device_name(failing, 3), None);
assert_eq!(device_name(unnamed, 3), None);
}
#[test]
fn a_function_list_with_gaps_is_unavailable() {
let mut fns = function_list();
fns.nvEncReconfigureEncoder = None;
let err = Api::new(fns, None).err().expect("incomplete");
assert!(err.to_string().contains("nvEncReconfigureEncoder"), "{err}");
}
#[test]
fn accepts_up_to_120_fps_with_the_layers_of_60_fps() {
let encoder = open_mock(config(1280, 720, 120)).expect("encoder");
assert_eq!(encoder.temporal_layers(), 4);
for fps in [0, 121] {
assert!(matches!(
open_mock(config(1280, 720, fps)),
Err(Error::InvalidConfig(_))
));
}
}
#[test]
fn a_requested_layer_count_replaces_the_automatic_one() {
for layers in 1..=4 {
let mut encoder =
open_mock(config(1280, 720, 30).with_temporal_layers(layers)).expect("encoder");
assert_eq!(encoder.temporal_layers(), layers);
encoder.set_fps(60).expect("fps");
assert_eq!(encoder.temporal_layers(), layers);
}
}
#[test]
fn rejects_a_layer_count_outside_1_to_4() {
for layers in [0, 5] {
assert!(matches!(
open_mock(config(1280, 720, 30).with_temporal_layers(layers)),
Err(Error::InvalidConfig(_))
));
}
}
#[test]
fn rejects_more_requested_layers_than_the_gpu_has() {
mock(|m| m.max_layers = 2);
assert!(matches!(
open_mock(config(1280, 720, 30).with_temporal_layers(3)),
Err(Error::InvalidConfig(_))
));
let encoder = open_mock(config(1280, 720, 30).with_temporal_layers(2)).expect("encoder");
assert_eq!(encoder.temporal_layers(), 2);
}
#[test]
fn rejects_a_picture_above_the_maximum_size() {
assert!(matches!(
open_mock(config(1920, 1080, 30).with_max_size(1280, 720)),
Err(Error::InvalidConfig(_))
));
let mut encoder =
open_mock(config(1280, 720, 30).with_max_size(1280, 720)).expect("encoder");
assert!(matches!(
encoder.set_resolution(1920, 1080),
Err(Error::InvalidConfig(_))
));
assert_eq!(encoder.config().width, 1280);
}
#[test]
fn ignores_a_thread_count() {
let encoder = open_mock(config(1280, 720, 30).with_threads(2)).expect("encoder");
assert_eq!(encoder.config().threads, Some(2));
}
}