use std::ptr;
use crate::codec::{Codec, VideoDecoder};
use crate::frame::{MAX_DECODED_HEIGHT, MAX_DECODED_WIDTH, check_decoded_size};
use crate::{Error, I420Frame, Result};
mod ffi {
#![allow(
non_upper_case_globals,
non_camel_case_types,
non_snake_case,
dead_code,
unsafe_op_in_unsafe_fn,
clippy::all
)]
include!(concat!(env!("OUT_DIR"), "/dav1d.rs"));
}
const THREADS: i32 = 2;
pub struct Av1Decoder {
ctx: *mut ffi::Dav1dContext,
}
unsafe impl Send for Av1Decoder {}
impl Av1Decoder {
pub fn new() -> Result<Self> {
let settings = decoder_settings();
let mut ctx = ptr::null_mut();
check(
unsafe { ffi::dav1d_open(&mut ctx, &settings) },
"decoder init",
)?;
Ok(Self { ctx })
}
pub fn decode(&mut self, data: &[u8]) -> Result<Option<I420Frame>> {
if data.is_empty() {
return Err(Error::InvalidFrame("empty frame".into()));
}
unsafe {
let mut input = std::mem::zeroed::<ffi::Dav1dData>();
let buf = ffi::dav1d_data_create(&mut input, data.len());
if buf.is_null() {
return Err(codec_error("allocate input", "out of memory".into()));
}
ptr::copy_nonoverlapping(data.as_ptr(), buf, data.len());
let mut picture = None;
let result = loop {
let status = ffi::dav1d_send_data(self.ctx, &mut input);
if status == again() {
match self.next_picture() {
Ok(Some(frame)) => picture = Some(frame),
Ok(None) => break Err(codec_error("decode", "decoder stalled".into())),
Err(err) => break Err(err),
}
} else if let Err(err) = check(status, "decode") {
break Err(err);
} else if input.sz == 0 {
break Ok(());
}
};
if input.sz > 0 {
ffi::dav1d_data_unref(&mut input);
}
result?;
while let Some(frame) = self.next_picture()? {
picture = Some(frame);
}
Ok(picture)
}
}
unsafe fn next_picture(&mut self) -> Result<Option<I420Frame>> {
unsafe {
let mut pic = std::mem::zeroed::<ffi::Dav1dPicture>();
let status = ffi::dav1d_get_picture(self.ctx, &mut pic);
if status == again() {
return Ok(None);
}
check(status, "get picture")?;
let frame = copy_picture(&pic);
ffi::dav1d_picture_unref(&mut pic);
frame.map(Some)
}
}
}
impl VideoDecoder for Av1Decoder {
fn codec(&self) -> Codec {
Codec::Av1
}
fn decode(&mut self, data: &[u8]) -> Result<Option<I420Frame>> {
Av1Decoder::decode(self, data)
}
}
impl Drop for Av1Decoder {
fn drop(&mut self) {
unsafe { ffi::dav1d_close(&mut self.ctx) }
}
}
fn decoder_settings() -> ffi::Dav1dSettings {
let mut settings = unsafe { std::mem::zeroed::<ffi::Dav1dSettings>() };
unsafe { ffi::dav1d_default_settings(&mut settings) };
settings.n_threads = THREADS;
settings.max_frame_delay = 1;
settings.frame_size_limit = MAX_DECODED_WIDTH * MAX_DECODED_HEIGHT;
settings.logger.callback = None;
settings
}
fn again() -> i32 {
-(ffi::EAGAIN as i32)
}
fn check(status: i32, operation: &'static str) -> Result<()> {
if status >= 0 {
return Ok(());
}
Err(codec_error(operation, format!("error {}", -status)))
}
fn codec_error(operation: &'static str, message: String) -> Error {
Error::Codec {
library: "dav1d",
operation,
message,
}
}
unsafe fn copy_picture(pic: &ffi::Dav1dPicture) -> Result<I420Frame> {
if pic.p.layout != ffi::DAV1D_PIXEL_LAYOUT_I420 || pic.p.bpc != 8 {
return Err(Error::InvalidFrame(format!(
"decoder produced layout {} at {} bits, expected 8-bit I420",
pic.p.layout, pic.p.bpc
)));
}
let (w, h) = (pic.p.w as u32, pic.p.h as u32);
check_decoded_size(w, h)?;
let mut data = Vec::with_capacity(I420Frame::buffer_len(w, h));
let chroma = (w.div_ceil(2) as usize, h.div_ceil(2) as usize);
let planes = [
(w as usize, h as usize, pic.stride[0]),
(chroma.0, chroma.1, pic.stride[1]),
(chroma.0, chroma.1, pic.stride[1]),
];
for (plane, (plane_w, plane_h, stride)) in planes.into_iter().enumerate() {
let base = pic.data[plane] as *const u8;
for row in 0..plane_h {
let line =
unsafe { std::slice::from_raw_parts(base.offset(row as isize * stride), plane_w) };
data.extend_from_slice(line);
}
}
I420Frame::new(w, h, data)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn decoder_refuses_frames_beyond_the_wire_limit() {
let settings = decoder_settings();
assert_eq!(
settings.frame_size_limit,
MAX_DECODED_WIDTH * MAX_DECODED_HEIGHT
);
assert_ne!(settings.frame_size_limit, 0, "0 means unlimited");
}
}