1use std::io::Write;
4
5use crate::colorspace::Colorspace;
6use crate::decode::{
7 is_forbidden_param_byte, parse_stream_params, validate_param_list, MAX_HEADER_LINE,
8};
9use crate::{Error, Interlace, Ratio};
10
11#[derive(Debug, Clone)]
17pub struct EncoderBuilder {
18 width: usize,
19 height: usize,
20 framerate: Ratio,
21 colorspace: Colorspace,
22 pixel_aspect: Option<Ratio>,
23 interlace: Option<Interlace>,
24 extensions: Vec<Vec<u8>>,
25 raw: Option<Vec<u8>>,
26}
27
28impl EncoderBuilder {
29 pub fn new(width: usize, height: usize, framerate: Ratio) -> Self {
31 EncoderBuilder {
32 width,
33 height,
34 framerate,
35 colorspace: Colorspace::C420,
36 pixel_aspect: None,
37 interlace: None,
38 extensions: Vec::new(),
39 raw: None,
40 }
41 }
42
43 pub fn colorspace(mut self, cs: Colorspace) -> Self {
45 self.colorspace = cs;
46 self
47 }
48
49 pub fn pixel_aspect(mut self, aspect: Ratio) -> Self {
52 self.pixel_aspect = Some(aspect);
53 self
54 }
55
56 pub fn interlace(mut self, interlace: Interlace) -> Self {
59 self.interlace = Some(interlace);
60 self
61 }
62
63 pub fn extension(mut self, value: &[u8]) -> Result<Self, Error> {
68 if value.is_empty()
69 || value
70 .iter()
71 .any(|&b| b == b' ' || is_forbidden_param_byte(b))
72 {
73 return Err(Error::BadInput);
74 }
75 self.extensions.push(value.to_vec());
76 Ok(self)
77 }
78
79 pub fn raw_params(mut self, raw: &[u8]) -> Result<Self, Error> {
96 validate_param_list(raw).map_err(|_| Error::BadInput)?;
97 let params = parse_stream_params(raw)?;
98 self.width = params.width;
99 self.height = params.height;
100 self.colorspace = params.colorspace;
101 self.raw = Some(raw.to_vec());
102 Ok(self)
103 }
104
105 pub fn write_header<W: Write>(self, mut writer: W) -> Result<Encoder<W>, Error> {
112 if self.width == 0 || self.height == 0 || self.framerate.den == 0 {
113 return Err(Error::BadInput);
114 }
115 let plane_sizes = self.colorspace.plane_sizes(self.width, self.height)?;
116
117 let mut header: Vec<u8> = Vec::with_capacity(64);
118 header.extend_from_slice(b"YUV4MPEG2 ");
119 match &self.raw {
120 Some(raw) => header.extend_from_slice(raw),
121 None => {
122 write!(
123 header,
124 "W{} H{} F{}:{}",
125 self.width, self.height, self.framerate.num, self.framerate.den
126 )
127 .map_err(Error::Io)?;
128 let interlace_char = match self.interlace {
129 Some(Interlace::Progressive) => Some('p'),
130 Some(Interlace::TopFirst) => Some('t'),
131 Some(Interlace::BottomFirst) => Some('b'),
132 Some(Interlace::Mixed) => Some('m'),
133 _ => None,
134 };
135 if let Some(c) = interlace_char {
136 write!(header, " I{c}").map_err(Error::Io)?;
137 }
138 if let Some(aspect) = self.pixel_aspect {
139 write!(header, " A{}:{}", aspect.num, aspect.den).map_err(Error::Io)?;
140 }
141 write!(header, " C{}", self.colorspace.tag()).map_err(Error::Io)?;
142 for ext in &self.extensions {
143 header.extend_from_slice(b" X");
144 header.extend_from_slice(ext);
145 }
146 }
147 }
148 header.push(b'\n');
149 if header.len() > MAX_HEADER_LINE {
150 return Err(Error::Limits);
151 }
152 writer.write_all(&header).map_err(Error::from)?;
153
154 let scratch = if self.colorspace.bytes_per_sample() == 2 {
155 vec![0u8; plane_sizes[0]]
156 } else {
157 Vec::new()
158 };
159
160 Ok(Encoder {
161 writer,
162 plane_sizes,
163 bit_depth: self.colorspace.bit_depth(),
164 scratch,
165 })
166 }
167}
168
169pub struct Encoder<W: Write> {
175 writer: W,
176 plane_sizes: [usize; 3],
177 bit_depth: u8,
178 scratch: Vec<u8>,
179}
180
181impl<W: Write> Encoder<W> {
182 pub fn write_frame(&mut self, planes: [&[u8]; 3]) -> Result<(), Error> {
186 self.write_frame_with_params(planes, b"")
187 }
188
189 pub fn write_frame_with_params(
198 &mut self,
199 planes: [&[u8]; 3],
200 params: &[u8],
201 ) -> Result<(), Error> {
202 for (plane, &size) in planes.iter().zip(self.plane_sizes.iter()) {
203 if plane.len() != size {
204 return Err(Error::BadInput);
205 }
206 }
207 self.write_frame_header(params)?;
208 for plane in planes {
209 if !plane.is_empty() {
210 self.writer.write_all(plane).map_err(Error::from)?;
211 }
212 }
213 Ok(())
214 }
215
216 pub fn write_frame_u16(&mut self, planes: [&[u16]; 3]) -> Result<(), Error> {
223 if self.scratch.is_empty() {
224 return Err(Error::BadInput);
225 }
226 let max = if self.bit_depth >= 16 {
227 u16::MAX
228 } else {
229 (1u16 << self.bit_depth) - 1
230 };
231 for (plane, &size) in planes.iter().zip(self.plane_sizes.iter()) {
232 if plane.len() != size / 2 {
233 return Err(Error::BadInput);
234 }
235 if plane.iter().any(|&s| s > max) {
236 return Err(Error::BadInput);
237 }
238 }
239 self.write_frame_header(b"")?;
240 for plane in planes {
241 if plane.is_empty() {
242 continue;
243 }
244 let out = &mut self.scratch[..plane.len() * 2];
245 for (sample, wire) in plane.iter().zip(out.chunks_exact_mut(2)) {
246 wire.copy_from_slice(&sample.to_le_bytes());
247 }
248 self.writer.write_all(out).map_err(Error::from)?;
249 }
250 Ok(())
251 }
252
253 fn write_frame_header(&mut self, params: &[u8]) -> Result<(), Error> {
254 if !params.is_empty() {
255 validate_param_list(params).map_err(|_| Error::BadInput)?;
256 if 5 + 1 + params.len() + 1 > MAX_HEADER_LINE {
257 return Err(Error::Limits);
258 }
259 }
260 self.writer.write_all(b"FRAME").map_err(Error::from)?;
261 if !params.is_empty() {
262 self.writer.write_all(b" ").map_err(Error::from)?;
263 self.writer.write_all(params).map_err(Error::from)?;
264 }
265 self.writer.write_all(b"\n").map_err(Error::from)?;
266 Ok(())
267 }
268
269 pub fn into_inner(mut self) -> Result<W, Error> {
271 self.writer.flush().map_err(Error::from)?;
272 Ok(self.writer)
273 }
274}
275
276impl<W: Write> std::fmt::Debug for Encoder<W> {
277 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
278 f.debug_struct("Encoder")
279 .field("plane_sizes", &self.plane_sizes)
280 .field("bit_depth", &self.bit_depth)
281 .finish_non_exhaustive()
282 }
283}