1 use nihav_core::demuxers::*;
4 struct Y4MDemuxer<'a> {
5 src: &'a mut ByteReader<'a>,
15 impl<'a> DemuxCore<'a> for Y4MDemuxer<'a> {
16 fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> {
17 let format = self.parse_header()?;
18 seek_index.mode = SeekIndexMode::Automatic;
20 let vhdr = NAVideoInfo::new(self.width, self.height, false, format);
21 let vci = NACodecTypeInfo::Video(vhdr);
22 let vinfo = NACodecInfo::new("rawvideo", vci, None);
23 if strmgr.add_stream(NAStream::new(StreamType::Video, 0, vinfo, self.fps_num, self.fps_den, 0)).is_none() {
24 return Err(DemuxerError::MemoryError);
30 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
31 let mut marker = [0u8; 6];
32 let res = self.src.read_buf(&mut marker);
34 Err(ByteIOError::EOF) => return Err(DemuxerError::EOF),
35 Err(err) => return Err(err.into()),
38 validate!(&marker == b"FRAME\n");
39 let stream = strmgr.get_stream(0).unwrap();
40 let ts = stream.make_ts(Some(self.frameno), None, None);
41 let pkt = self.src.read_packet(stream, ts, true, self.frame_size)?;
46 fn seek(&mut self, time: NATimePoint, _seek_index: &SeekIndex) -> DemuxerResult<()> {
47 let new_fno = match time {
48 NATimePoint::PTS(pts) => {
51 NATimePoint::Milliseconds(ms) => {
52 if (self.fps_num == 0) || (self.fps_den == 0) {
53 return Err(DemuxerError::SeekError);
55 NATimeInfo::time_to_ts(ms, 1000, self.fps_num, self.fps_den)
57 NATimePoint::None => return Err(DemuxerError::SeekError),
59 let pos = self.hdr_size + new_fno * ((self.frame_size + 6) as u64);
60 self.src.seek(SeekFrom::Start(pos))?;
61 self.frameno = new_fno;
65 fn get_duration(&self) -> u64 { 0 }
68 impl<'a> NAOptionHandler for Y4MDemuxer<'a> {
69 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
70 fn set_options(&mut self, _options: &[NAOption]) { }
71 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
74 impl<'a> Y4MDemuxer<'a> {
75 fn new(io: &'a mut ByteReader<'a>) -> Self {
87 fn parse_header(&mut self) -> DemuxerResult<NAPixelFormaton> {
88 let mut format = YUV420_FORMAT;
90 let mut magic = [0u8; 10];
91 self.src.read_buf(&mut magic)?;
92 validate!(&magic == b"YUV4MPEG2 ");
93 while let Ok((last, tok)) = read_token(self.src) {
94 let (id, val) = tok.split_at(1);
95 validate!(id.len() == 1);
96 match id.bytes().next().unwrap() {
98 if let Ok(w) = val.parse::<usize>() {
103 if let Ok(h) = val.parse::<usize>() {
108 if let Ok(fden) = val.parse::<u32>() {
112 let vals: Vec<&str> = val.split(':').collect();
114 if let Ok(fnum) = vals[1].parse::<u32>() {
117 if let Ok(fden) = vals[0].parse::<u32>() {
124 let fmt_str = val.as_bytes();
125 validate!(fmt_str.len() >= 3);
126 let mut pix_name: [u8; 7] = *b"yuv000p";
127 validate!(fmt_str[0] == b'4');
128 pix_name[3..6].copy_from_slice(&fmt_str[..3]);
130 if let Ok(fmt_name) = std::str::from_utf8(&pix_name) {
131 if let Ok(val) = NAPixelFormaton::from_str(fmt_name) {
135 if format.model.is_yuv() {
136 format.model = ColorModel::YUV(YUVSubmodel::YCbCr);
137 if fmt_str.len() > 3 {
138 let (_, tail) = fmt_str.split_at(3);
140 format.model = ColorModel::YUV(YUVSubmodel::YUVJ);
152 validate!(self.width > 0 && self.height > 0);
154 for chr in format.comp_info.iter().flatten() {
155 self.frame_size += chr.get_data_size(self.width, self.height);
157 validate!(self.frame_size > 0);
163 fn read_token(src: &mut ByteReader) -> DemuxerResult<(bool, String)> {
164 let mut string = String::new();
167 let b = src.read_byte()?;
169 b' ' | b'\n' => { ws = b; break; },
170 0..=0x7F => string.push(b as char),
171 _ => return Err(DemuxerError::InvalidData),
175 Ok((ws == b'\n', string))
178 pub struct Y4MDemuxerCreator { }
180 impl DemuxerCreator for Y4MDemuxerCreator {
181 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
182 Box::new(Y4MDemuxer::new(br))
184 fn get_name(&self) -> &'static str { "yuv4mpeg" }
193 fn test_y4m_demux() {
194 // sample: self-created with avconv
195 let mut file = File::open("assets/Misc/test.y4m").unwrap();
196 let mut fr = FileReader::new_read(&mut file);
197 let mut br = ByteReader::new(&mut fr);
198 let mut dmx = Y4MDemuxer::new(&mut br);
199 let mut sm = StreamManager::new();
200 let mut si = SeekIndex::new();
201 dmx.open(&mut sm, &mut si).unwrap();
204 let pktres = dmx.get_frame(&mut sm);
205 if let Err(e) = pktres {
206 if e == DemuxerError::EOF { break; }
209 let pkt = pktres.unwrap();
210 println!("Got {}", pkt);