X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=src%2Fdemuxers%2Favi.rs;h=bde38da041d9ed39788b2717079108a24845cc25;hb=bcfeae48693ae98aa504b86e6ced38de0573e302;hp=99c730522c21221b4a364fc9d35387d0899ccdff;hpb=c84e0be04d7cb9be2f3df7c98d24c0c01c65909b;p=nihav.git diff --git a/src/demuxers/avi.rs b/src/demuxers/avi.rs index 99c7305..bde38da 100644 --- a/src/demuxers/avi.rs +++ b/src/demuxers/avi.rs @@ -1,4 +1,5 @@ use super::*; +use register; use super::DemuxerError::*; use io::byteio::*; use frame::*; @@ -37,15 +38,16 @@ impl StreamState { } #[allow(dead_code)] -pub struct AVIDemuxer<'a> { +struct AVIDemuxer<'a> { opened: bool, src: &'a mut ByteReader<'a>, cur_frame: Vec, num_streams: u8, - dmx: Demuxer, size: usize, movi_size: usize, sstate: StreamState, + tb_num: u32, + tb_den: u32, } #[derive(Debug,Clone,Copy,PartialEq)] @@ -56,37 +58,56 @@ enum RIFFTag { struct RIFFParser { tag: RIFFTag, - parse: fn(&mut AVIDemuxer, size: usize) -> DemuxerResult, + parse: fn(&mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult, } -impl<'a> Demux<'a> for AVIDemuxer<'a> { +impl<'a> DemuxCore<'a> for AVIDemuxer<'a> { #[allow(unused_variables)] - fn open(&mut self) -> DemuxerResult<()> { - self.read_header()?; + fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> { + self.read_header(strmgr)?; self.opened = true; Ok(()) } - fn get_frame(&mut self) -> DemuxerResult { + fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult { if !self.opened { return Err(NoSuchInput); } if self.movi_size == 0 { return Err(EOF); } let mut tag: [u8; 4] = [0; 4]; loop { + if (self.src.tell() & 1) == 1 { + self.src.read_skip(1)?; + self.movi_size -= 1; + if self.movi_size == 0 { return Err(EOF); } + } self.src.read_buf(&mut tag)?; let size = self.src.read_u32le()? as usize; if mktag!(tag) == mktag!(b"JUNK") { self.movi_size -= size + 8; self.src.read_skip(size)?; + if self.movi_size == 0 { return Err(EOF); } + continue; + } + if mktag!(tag) == mktag!(b"LIST") { + self.movi_size -= 12; + self.src.read_skip(4)?; + if self.movi_size == 0 { return Err(EOF); } continue; } if tag[0] < b'0' || tag[0] > b'9' || tag[1] < b'0' || tag[1] > b'9' { return Err(InvalidData); } let stream_no = (tag[0] - b'0') * 10 + (tag[1] - b'0'); - let str = self.dmx.get_stream(stream_no as usize); + let str = strmgr.get_stream(stream_no as usize); if let None = str { return Err(InvalidData); } let stream = str.unwrap(); - let pkt = self.src.read_packet(stream, Some(self.cur_frame[stream_no as usize]), None, None, false, size)?; + if size == 0 { + self.movi_size -= 8; + if self.movi_size == 0 { return Err(EOF); } + continue; + } + let (tb_num, tb_den) = stream.get_timebase(); + let ts = NATimeInfo::new(Some(self.cur_frame[stream_no as usize]), None, None, tb_num, tb_den); + let pkt = self.src.read_packet(stream, ts, false, size)?; self.cur_frame[stream_no as usize] += 1; self.movi_size -= size + 8; @@ -102,7 +123,7 @@ impl<'a> Demux<'a> for AVIDemuxer<'a> { } impl<'a> AVIDemuxer<'a> { - pub fn new(io: &'a mut ByteReader<'a>) -> Self { + fn new(io: &'a mut ByteReader<'a>) -> Self { AVIDemuxer { cur_frame: Vec::new(), num_streams: 0, @@ -111,11 +132,12 @@ impl<'a> AVIDemuxer<'a> { size: 0, movi_size: 0, sstate: StreamState::new(), - dmx: Demuxer::new() + tb_num: 0, + tb_den: 0, } } - fn parse_chunk(&mut self, end_tag: RIFFTag, csize: usize, depth: u16) -> DemuxerResult<(usize, bool)> { + fn parse_chunk(&mut self, strmgr: &mut StreamManager, end_tag: RIFFTag, csize: usize, depth: u16) -> DemuxerResult<(usize, bool)> { if csize < 8 { return Err(InvalidData); } if depth > 42 { return Err(InvalidData); } @@ -125,36 +147,49 @@ impl<'a> AVIDemuxer<'a> { if RIFFTag::Chunk(tag) == end_tag { return Ok((size, true)); } - let ltag = if is_list_tag(tag) { self.src.read_u32be()? } else { 0 }; + let is_list = is_list_tag(tag); + let ltag = if is_list { self.src.read_u32be()? } else { 0 }; if RIFFTag::List(tag, ltag) == end_tag { return Ok((size, true)); } for i in 0..CHUNKS.len() { if RIFFTag::Chunk(tag) == CHUNKS[i].tag { - let psize = (CHUNKS[i].parse)(self, size)?; + let psize = (CHUNKS[i].parse)(self, strmgr, size)?; if psize != size { return Err(InvalidData); } + if (psize & 1) == 1 { self.src.read_skip(1)?; } return Ok((size + 8, false)); } if RIFFTag::List(tag, ltag) == CHUNKS[i].tag { let mut rest_size = size - 4; - let psize = (CHUNKS[i].parse)(self, rest_size)?; + let psize = (CHUNKS[i].parse)(self, strmgr, rest_size)?; if psize > rest_size { return Err(InvalidData); } rest_size -= psize; while rest_size > 0 { - let (psize, _) = self.parse_chunk(end_tag, rest_size, depth+1)?; + let (psize, _) = self.parse_chunk(strmgr, end_tag, rest_size, depth+1)?; if psize > rest_size { return Err(InvalidData); } rest_size -= psize; + if (psize & 1) == 1 { + if rest_size > 0 { + rest_size -= 1; + } + } } return Ok((size + 8, false)); } } - self.src.read_skip(size)?; + if !is_list { + self.src.read_skip(size)?; + } else { + if size < 4 { return Err(InvalidData); } + self.src.read_skip(size - 4)?; + } + if (size & 1) == 1 { self.src.read_skip(1)?; } return Ok((size + 8, false)); } - fn read_header(&mut self) -> DemuxerResult<()> { + fn read_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> { let riff_tag = self.src.read_u32be()?; let size = self.src.read_u32le()? as usize; let avi_tag = self.src.read_u32be()?; @@ -164,7 +199,7 @@ impl<'a> AVIDemuxer<'a> { self.size = size; let mut rest_size = size; loop { - let (csz, end) = self.parse_chunk(RIFFTag::List(mktag!(b"LIST"), mktag!(b"movi")), rest_size,0)?; + let (csz, end) = self.parse_chunk(strmgr, RIFFTag::List(mktag!(b"LIST"), mktag!(b"movi")), rest_size,0)?; if end { self.movi_size = csz - 4; break; } rest_size -= csz; } @@ -204,17 +239,17 @@ fn is_list_tag(tag: u32) -> bool { } #[allow(unused_variables)] -fn parse_hdrl(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult { +fn parse_hdrl(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult { Ok(0) } #[allow(unused_variables)] -fn parse_strl(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult { +fn parse_strl(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult { Ok(0) } #[allow(unused_variables)] -fn parse_strh(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult { +fn parse_strh(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult { if size < 0x38 { return Err(InvalidData); } let tag = dmx.src.read_u32be()?; //stream type let fcc = dmx.src.read_u32be()?; //handler(fourcc) @@ -222,8 +257,8 @@ fn parse_strh(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult { dmx.src.read_skip(2)?; //priority dmx.src.read_skip(2)?; //language dmx.src.read_skip(4)?; //initial frames - let scale = dmx.src.read_u32le()?; //scale - let rate = dmx.src.read_u32le()?; //rate + dmx.tb_num = dmx.src.read_u32le()?; //scale + dmx.tb_den = dmx.src.read_u32le()?; //rate dmx.src.read_skip(4)?; //start dmx.src.read_skip(4)?; //length dmx.src.read_skip(4)?; //buf size @@ -251,17 +286,17 @@ fn parse_strh(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult { Ok(size) } -fn parse_strf(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult { +fn parse_strf(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult { if let None = dmx.sstate.strm_type { return Err(InvalidData); } match dmx.sstate.strm_type.unwrap() { - StreamType::Video => parse_strf_vids(dmx, size), - StreamType::Audio => parse_strf_auds(dmx, size), - _ => parse_strf_xxxx(dmx, size), + StreamType::Video => parse_strf_vids(dmx, strmgr, size), + StreamType::Audio => parse_strf_auds(dmx, strmgr, size), + _ => parse_strf_xxxx(dmx, strmgr, size), } } #[allow(unused_variables)] -fn parse_strf_vids(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult { +fn parse_strf_vids(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult { if size < 40 { return Err(InvalidData); } let bi_size = dmx.src.read_u32le()?; if (bi_size as usize) > size { return Err(InvalidData); } @@ -269,7 +304,8 @@ fn parse_strf_vids(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult { let height = dmx.src.read_u32le()? as i32; let planes = dmx.src.read_u16le()?; let bitcount = dmx.src.read_u16le()?; - let compression = dmx.src.read_u32be()?; + let mut compression: [u8; 4] = [0; 4]; + dmx.src.read_buf(&mut compression)?; let img_size = dmx.src.read_u32le()?; let xdpi = dmx.src.read_u32le()?; let ydpi = dmx.src.read_u32le()?; @@ -278,47 +314,55 @@ fn parse_strf_vids(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult { let flip = height < 0; let format = if bitcount > 8 { RGB24_FORMAT } else { PAL8_FORMAT }; - let vhdr = NAVideoInfo::new(width, if flip { -height as u32 } else { height as u32}, flip, PAL8_FORMAT); + let vhdr = NAVideoInfo::new(width as usize, if flip { -height as usize } else { height as usize}, flip, PAL8_FORMAT); let vci = NACodecTypeInfo::Video(vhdr); let edata = dmx.read_extradata(size - 40)?; - let vinfo = NACodecInfo::new(vci, edata); - let res = dmx.dmx.add_stream(NAStream::new(StreamType::Video, dmx.sstate.strm_no as u32, vinfo)); + let cname = match register::find_codec_from_avi_fourcc(&compression) { + None => "unknown", + Some(name) => name, + }; + let vinfo = NACodecInfo::new(cname, vci, edata); + let res = strmgr.add_stream(NAStream::new(StreamType::Video, dmx.sstate.strm_no as u32, vinfo, dmx.tb_num, dmx.tb_den)); if let None = res { return Err(MemoryError); } dmx.sstate.reset(); Ok(size) } #[allow(unused_variables)] -fn parse_strf_auds(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult { +fn parse_strf_auds(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult { if size < 16 { return Err(InvalidData); } let w_format_tag = dmx.src.read_u16le()?; let channels = dmx.src.read_u16le()?; let samplespersec = dmx.src.read_u32le()?; let avgbytespersec = dmx.src.read_u32le()?; let block_align = dmx.src.read_u16le()?; - let bits_per_sample = dmx.src.read_u16le()?; + let bits_per_sample = dmx.src.read_u16le()? * 8; let soniton = NASoniton::new(bits_per_sample as u8, SONITON_FLAG_SIGNED); let ahdr = NAAudioInfo::new(samplespersec, channels as u8, soniton, block_align as usize); let edata = dmx.read_extradata(size - 16)?; - let ainfo = NACodecInfo::new(NACodecTypeInfo::Audio(ahdr), edata); - let res = dmx.dmx.add_stream(NAStream::new(StreamType::Audio, dmx.sstate.strm_no as u32, ainfo)); + let cname = match register::find_codec_from_wav_twocc(w_format_tag) { + None => "unknown", + Some(name) => name, + }; + let ainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata); + let res = strmgr.add_stream(NAStream::new(StreamType::Audio, dmx.sstate.strm_no as u32, ainfo, dmx.tb_num, dmx.tb_den)); if let None = res { return Err(MemoryError); } dmx.sstate.reset(); Ok(size) } -fn parse_strf_xxxx(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult { +fn parse_strf_xxxx(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult { let edata = dmx.read_extradata(size)?; - let info = NACodecInfo::new(NACodecTypeInfo::None, edata); - let res = dmx.dmx.add_stream(NAStream::new(StreamType::Data, dmx.sstate.strm_no as u32, info)); + let info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata); + let res = strmgr.add_stream(NAStream::new(StreamType::Data, dmx.sstate.strm_no as u32, info, dmx.tb_num, dmx.tb_den)); if let None = res { return Err(MemoryError); } dmx.sstate.reset(); Ok(size) } #[allow(unused_variables)] -fn parse_avih(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult { +fn parse_avih(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult { if size < 0x38 { return Err(InvalidData); } let timebase = dmx.src.read_u32le()?; //microsec per frame dmx.src.read_skip(4)?; //max frame size @@ -340,11 +384,21 @@ fn parse_avih(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult { Ok(size) } -fn parse_junk(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult { +#[allow(unused_variables)] +fn parse_junk(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult { dmx.src.read_skip(size)?; Ok(size) } +pub struct AVIDemuxerCreator { } + +impl DemuxerCreator for AVIDemuxerCreator { + fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box + 'a> { + Box::new(AVIDemuxer::new(br)) + } + fn get_name(&self) -> &'static str { "avi" } +} + #[cfg(test)] mod test { use super::*; @@ -356,12 +410,13 @@ mod test { let mut fr = FileReader::new_read(&mut file); let mut br = ByteReader::new(&mut fr); let mut dmx = AVIDemuxer::new(&mut br); - dmx.open().unwrap(); + let mut sm = StreamManager::new(); + dmx.open(&mut sm).unwrap(); loop { - let pktres = dmx.get_frame(); + let pktres = dmx.get_frame(&mut sm); if let Err(e) = pktres { - if (e as i32) == (DemuxerError::EOF as i32) { break; } + if e == DemuxerError::EOF { break; } panic!("error"); } let pkt = pktres.unwrap();