use std::io::Write;
use crate::colorspace::Colorspace;
use crate::decode::{
is_forbidden_param_byte, parse_stream_params, validate_param_list, MAX_HEADER_LINE,
};
use crate::{Error, Interlace, Ratio};
#[derive(Debug, Clone)]
pub struct EncoderBuilder {
width: usize,
height: usize,
framerate: Ratio,
colorspace: Colorspace,
pixel_aspect: Option<Ratio>,
interlace: Option<Interlace>,
extensions: Vec<Vec<u8>>,
raw: Option<Vec<u8>>,
}
impl EncoderBuilder {
pub fn new(width: usize, height: usize, framerate: Ratio) -> Self {
EncoderBuilder {
width,
height,
framerate,
colorspace: Colorspace::C420,
pixel_aspect: None,
interlace: None,
extensions: Vec::new(),
raw: None,
}
}
pub fn colorspace(mut self, cs: Colorspace) -> Self {
self.colorspace = cs;
self
}
pub fn pixel_aspect(mut self, aspect: Ratio) -> Self {
self.pixel_aspect = Some(aspect);
self
}
pub fn interlace(mut self, interlace: Interlace) -> Self {
self.interlace = Some(interlace);
self
}
pub fn extension(mut self, value: &[u8]) -> Result<Self, Error> {
if value.is_empty()
|| value
.iter()
.any(|&b| b == b' ' || is_forbidden_param_byte(b))
{
return Err(Error::BadInput);
}
self.extensions.push(value.to_vec());
Ok(self)
}
pub fn raw_params(mut self, raw: &[u8]) -> Result<Self, Error> {
validate_param_list(raw).map_err(|_| Error::BadInput)?;
let params = parse_stream_params(raw)?;
self.width = params.width;
self.height = params.height;
self.colorspace = params.colorspace;
self.raw = Some(raw.to_vec());
Ok(self)
}
pub fn write_header<W: Write>(self, mut writer: W) -> Result<Encoder<W>, Error> {
if self.width == 0 || self.height == 0 || self.framerate.den == 0 {
return Err(Error::BadInput);
}
let plane_sizes = self.colorspace.plane_sizes(self.width, self.height)?;
let mut header: Vec<u8> = Vec::with_capacity(64);
header.extend_from_slice(b"YUV4MPEG2 ");
match &self.raw {
Some(raw) => header.extend_from_slice(raw),
None => {
write!(
header,
"W{} H{} F{}:{}",
self.width, self.height, self.framerate.num, self.framerate.den
)
.map_err(Error::Io)?;
let interlace_char = match self.interlace {
Some(Interlace::Progressive) => Some('p'),
Some(Interlace::TopFirst) => Some('t'),
Some(Interlace::BottomFirst) => Some('b'),
Some(Interlace::Mixed) => Some('m'),
_ => None,
};
if let Some(c) = interlace_char {
write!(header, " I{c}").map_err(Error::Io)?;
}
if let Some(aspect) = self.pixel_aspect {
write!(header, " A{}:{}", aspect.num, aspect.den).map_err(Error::Io)?;
}
write!(header, " C{}", self.colorspace.tag()).map_err(Error::Io)?;
for ext in &self.extensions {
header.extend_from_slice(b" X");
header.extend_from_slice(ext);
}
}
}
header.push(b'\n');
if header.len() > MAX_HEADER_LINE {
return Err(Error::Limits);
}
writer.write_all(&header).map_err(Error::from)?;
let scratch = if self.colorspace.bytes_per_sample() == 2 {
vec![0u8; plane_sizes[0]]
} else {
Vec::new()
};
Ok(Encoder {
writer,
plane_sizes,
bit_depth: self.colorspace.bit_depth(),
scratch,
})
}
}
pub struct Encoder<W: Write> {
writer: W,
plane_sizes: [usize; 3],
bit_depth: u8,
scratch: Vec<u8>,
}
impl<W: Write> Encoder<W> {
pub fn write_frame(&mut self, planes: [&[u8]; 3]) -> Result<(), Error> {
self.write_frame_with_params(planes, b"")
}
pub fn write_frame_with_params(
&mut self,
planes: [&[u8]; 3],
params: &[u8],
) -> Result<(), Error> {
for (plane, &size) in planes.iter().zip(self.plane_sizes.iter()) {
if plane.len() != size {
return Err(Error::BadInput);
}
}
self.write_frame_header(params)?;
for plane in planes {
if !plane.is_empty() {
self.writer.write_all(plane).map_err(Error::from)?;
}
}
Ok(())
}
pub fn write_frame_u16(&mut self, planes: [&[u16]; 3]) -> Result<(), Error> {
if self.scratch.is_empty() {
return Err(Error::BadInput);
}
let max = if self.bit_depth >= 16 {
u16::MAX
} else {
(1u16 << self.bit_depth) - 1
};
for (plane, &size) in planes.iter().zip(self.plane_sizes.iter()) {
if plane.len() != size / 2 {
return Err(Error::BadInput);
}
if plane.iter().any(|&s| s > max) {
return Err(Error::BadInput);
}
}
self.write_frame_header(b"")?;
for plane in planes {
if plane.is_empty() {
continue;
}
let out = &mut self.scratch[..plane.len() * 2];
for (sample, wire) in plane.iter().zip(out.chunks_exact_mut(2)) {
wire.copy_from_slice(&sample.to_le_bytes());
}
self.writer.write_all(out).map_err(Error::from)?;
}
Ok(())
}
fn write_frame_header(&mut self, params: &[u8]) -> Result<(), Error> {
if !params.is_empty() {
validate_param_list(params).map_err(|_| Error::BadInput)?;
if 5 + 1 + params.len() + 1 > MAX_HEADER_LINE {
return Err(Error::Limits);
}
}
self.writer.write_all(b"FRAME").map_err(Error::from)?;
if !params.is_empty() {
self.writer.write_all(b" ").map_err(Error::from)?;
self.writer.write_all(params).map_err(Error::from)?;
}
self.writer.write_all(b"\n").map_err(Error::from)?;
Ok(())
}
pub fn into_inner(mut self) -> Result<W, Error> {
self.writer.flush().map_err(Error::from)?;
Ok(self.writer)
}
}
impl<W: Write> std::fmt::Debug for Encoder<W> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Encoder")
.field("plane_sizes", &self.plane_sizes)
.field("bit_depth", &self.bit_depth)
.finish_non_exhaustive()
}
}