use std::io::{Read, Write};
use rff_core::{CodecId, Error, Packet, Rational, Result};
use rff_format::{Demuxer, Format, FormatRegistry, Input, MuxCaps, Muxer, Output, Stream};
pub fn register(registry: &mut FormatRegistry) {
registry.register(Format {
name: "jpeg",
long_name: "JPEG (JFIF) image",
extensions: &["jpg", "jpeg"],
demuxer: Some(|input| Box::new(JpegDemuxer::new(input))),
muxer: Some(|output| Box::new(JpegMuxer::new(output))),
muxer_path: None,
probe: Some(probe_jpeg),
mux_caps: MuxCaps::single(&[CodecId::Jpeg]).image(),
});
}
fn probe_jpeg(data: &[u8]) -> i32 {
if data.len() >= 3 && data[0] == 0xFF && data[1] == 0xD8 && data[2] == 0xFF {
100
} else {
0
}
}
fn jpeg_dimensions(buf: &[u8]) -> Option<(u32, u32)> {
if buf.len() < 2 || buf[0] != 0xFF || buf[1] != 0xD8 {
return None;
}
let mut i = 2;
while i + 1 < buf.len() {
if buf[i] != 0xFF {
i += 1;
continue;
}
let marker = buf[i + 1];
if marker == 0xFF || marker == 0x01 || (0xD0..=0xD9).contains(&marker) {
i += 2;
continue;
}
if (0xC0..=0xCF).contains(&marker) && marker != 0xC4 && marker != 0xC8 && marker != 0xCC {
if i + 9 > buf.len() {
return None;
}
let h = u16::from_be_bytes([buf[i + 5], buf[i + 6]]) as u32;
let w = u16::from_be_bytes([buf[i + 7], buf[i + 8]]) as u32;
return Some((w, h));
}
if i + 4 > buf.len() {
return None;
}
let len = u16::from_be_bytes([buf[i + 2], buf[i + 3]]) as usize;
i += 2 + len;
}
None
}
struct JpegDemuxer {
input: Option<Input>,
sample: Option<Vec<u8>>,
}
impl JpegDemuxer {
fn new(input: Input) -> JpegDemuxer {
JpegDemuxer {
input: Some(input),
sample: None,
}
}
}
impl Demuxer for JpegDemuxer {
fn read_header(&mut self) -> Result<Vec<Stream>> {
let mut input = self
.input
.take()
.ok_or_else(|| Error::invalid("jpeg demux: header already read"))?;
let mut buf = Vec::new();
input.read_to_end(&mut buf)?;
let (width, height) =
jpeg_dimensions(&buf).ok_or_else(|| Error::invalid("jpeg demux: not a JPEG file"))?;
self.sample = Some(buf);
let mut stream = Stream::new(0, CodecId::Jpeg);
stream.width = width;
stream.height = height;
stream.time_base = Rational::new(1, 1);
Ok(vec![stream])
}
fn read_packet(&mut self) -> Result<Packet> {
match self.sample.take() {
Some(data) => {
let mut packet = Packet::from_data(0, data);
packet.flags.keyframe = true;
packet.pts = Some(0);
Ok(packet)
}
None => Err(Error::Eof),
}
}
}
struct JpegMuxer {
out: Output,
}
impl JpegMuxer {
fn new(out: Output) -> JpegMuxer {
JpegMuxer { out }
}
}
impl Muxer for JpegMuxer {
fn write_header(&mut self, streams: &[Stream]) -> Result<()> {
match streams.first() {
Some(s) if s.codec_id == CodecId::Jpeg => Ok(()),
Some(_) => Err(Error::unsupported(
"jpeg mux: only the `mjpeg` codec is supported",
)),
None => Err(Error::invalid("jpeg mux: no streams")),
}
}
fn write_packet(&mut self, packet: &Packet) -> Result<()> {
self.out.write_all(&packet.data)?;
Ok(())
}
fn write_trailer(&mut self) -> Result<()> {
self.out.flush()?;
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Cursor;
fn jpeg_header_5x7() -> Vec<u8> {
let mut v = vec![0xFF, 0xD8]; v.extend_from_slice(&[0xFF, 0xC0, 0x00, 0x11, 0x08]);
v.extend_from_slice(&7u16.to_be_bytes());
v.extend_from_slice(&5u16.to_be_bytes());
v.extend_from_slice(&[3, 1, 0x22, 0, 2, 0x11, 0, 3, 0x11, 0]); v
}
#[test]
fn sniffs_and_reads_jpeg_dimensions() {
let jpg = jpeg_header_5x7();
assert_eq!(probe_jpeg(&jpg), 100);
assert_eq!(probe_jpeg(b"\xFF\xD8\xEEnope"), 0);
let mut dem = JpegDemuxer::new(Box::new(Cursor::new(jpg.clone())));
let streams = dem.read_header().unwrap();
assert_eq!(streams[0].codec_id, CodecId::Jpeg);
assert_eq!((streams[0].width, streams[0].height), (5, 7));
assert_eq!(dem.read_packet().unwrap().data, jpg);
assert!(matches!(dem.read_packet(), Err(Error::Eof)));
}
}