X-Git-Url: https://git.nihav.org/?p=nihav.git;a=blobdiff_plain;f=nihav-commonfmt%2Fsrc%2Fdemuxers%2Favi.rs;h=eb927e7e57846f545c248add1e754edd1cab5f45;hp=ec326ff9d2f3fe06f1452e757b7b09cb90453936;hb=a480a0de101483d802a11e72d758dae00fa4860a;hpb=b33d38e0cb9907f59e2f354ac7a2ff015e5e978c diff --git a/nihav-commonfmt/src/demuxers/avi.rs b/nihav-commonfmt/src/demuxers/avi.rs index ec326ff..eb927e7 100644 --- a/nihav-commonfmt/src/demuxers/avi.rs +++ b/nihav-commonfmt/src/demuxers/avi.rs @@ -1,5 +1,5 @@ use nihav_core::demuxers::*; -use nihav_core::register; +use nihav_registry::register; use nihav_core::demuxers::DemuxerError::*; macro_rules! mktag { @@ -34,6 +34,12 @@ impl StreamState { } } +struct PalInfo { + pal: Arc<[u8; 1024]>, + changed: bool, + stream_no: usize, +} + #[allow(dead_code)] struct AVIDemuxer<'a> { src: &'a mut ByteReader<'a>, @@ -46,6 +52,9 @@ struct AVIDemuxer<'a> { sstate: StreamState, tb_num: u32, tb_den: u32, + strm_duration: u32, + key_offs: Vec, + pal: Vec, } #[derive(Debug,Clone,Copy,PartialEq)] @@ -74,6 +83,7 @@ impl<'a> DemuxCore<'a> for AVIDemuxer<'a> { self.movi_size -= 1; if self.movi_size == 0 { return Err(EOF); } } + let is_keyframe = self.key_offs.binary_search(&self.src.tell()).is_ok(); self.src.read_buf(&mut tag)?; let size = self.src.read_u32le()? as usize; if mktag!(tag) == mktag!(b"JUNK") { @@ -88,13 +98,19 @@ impl<'a> DemuxCore<'a> for AVIDemuxer<'a> { if self.movi_size == 0 { return Err(EOF); } continue; } - if tag[0] == b'i' && tag[1] == b'x' { + if (tag[0] == b'i' && tag[1] == b'x') || (&tag == b"idx1") { return Err(EOF); } 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'); + if tag[2] == b'p' && tag[3] == b'c' { + self.parse_palette_change(stream_no as usize, size)?; + self.movi_size -= size; + if self.movi_size == 0 { return Err(EOF); } + continue; + } let str = strmgr.get_stream(stream_no as usize); if str.is_none() { return Err(InvalidData); } let stream = str.unwrap(); @@ -105,7 +121,14 @@ impl<'a> DemuxCore<'a> for AVIDemuxer<'a> { } 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)?; + let mut pkt = self.src.read_packet(stream, ts, is_keyframe, size)?; + for pe in self.pal.iter_mut() { + if pe.stream_no == (stream_no as usize) { + pkt.add_side_data(NASideData::Palette(pe.changed, pe.pal.clone())); + pe.changed = false; + break; + } + } self.cur_frame[stream_no as usize] += 1; self.movi_size -= size + 8; @@ -113,7 +136,7 @@ impl<'a> DemuxCore<'a> for AVIDemuxer<'a> { } } - fn seek(&mut self, time: u64, seek_index: &SeekIndex) -> DemuxerResult<()> { + fn seek(&mut self, time: NATimePoint, seek_index: &SeekIndex) -> DemuxerResult<()> { let ret = seek_index.find_pos(time); if ret.is_none() { return Err(DemuxerError::SeekError); @@ -130,6 +153,13 @@ impl<'a> DemuxCore<'a> for AVIDemuxer<'a> { Ok(()) } + fn get_duration(&self) -> u64 { 0 } +} + +impl<'a> NAOptionHandler for AVIDemuxer<'a> { + fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } + fn set_options(&mut self, _options: &[NAOption]) { } + fn query_option_value(&self, _name: &str) -> Option { None } } impl<'a> AVIDemuxer<'a> { @@ -145,6 +175,9 @@ impl<'a> AVIDemuxer<'a> { sstate: StreamState::new(), tb_num: 0, tb_den: 0, + strm_duration: 0, + key_offs: Vec::new(), + pal: Vec::new(), } } @@ -231,7 +264,7 @@ impl<'a> AVIDemuxer<'a> { if ret.is_err() { break; } let (csz, end) = ret.unwrap(); if end { - let _res = parse_idx1(&mut self.src, strmgr, seek_idx, csz, self.movi_pos); + let _res = parse_idx1(&mut self.src, strmgr, seek_idx, csz, self.movi_pos, &mut self.key_offs); break; } rest_size -= csz; @@ -254,6 +287,31 @@ impl<'a> AVIDemuxer<'a> { self.src.read_buf(&mut edvec)?; Ok(Some(edvec)) } + + fn parse_palette_change(&mut self, stream_no: usize, size: usize) -> DemuxerResult<()> { + for pe in self.pal.iter_mut() { + if pe.stream_no == stream_no { + let start_clr = self.src.read_byte()? as usize; + let len = self.src.read_byte()? as usize; + let _flags = self.src.read_u16le()?; + validate!(start_clr + len <= 256); + validate!(len * 4 + 4 == size); + let mut newpal = *pe.pal; + for i in start_clr..(start_clr + len) { + newpal[i * 4] = self.src.read_byte()?; + newpal[i * 4 + 1] = self.src.read_byte()?; + newpal[i * 4 + 2] = self.src.read_byte()?; + newpal[i * 4 + 3] = 0; + self.src.read_byte()?; // flags + } + pe.pal = Arc::new(newpal); + pe.changed = true; + return Ok(()); + } + } + self.src.read_skip(size)?; + Ok(()) + } } const RIFF_TAGS: &[[u32; 2]] = &[ @@ -305,7 +363,7 @@ fn parse_strh(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> 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.strm_duration = dmx.src.read_u32le()?; dmx.src.read_skip(4)?; //buf size dmx.src.read_skip(4)?; //quality dmx.src.read_skip(4)?; //sample size @@ -344,7 +402,7 @@ fn parse_strf(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> 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); } + if (bi_size as usize) < 40 { return Err(InvalidData); } let width = dmx.src.read_u32le()?; let height = dmx.src.read_u32le()? as i32; let planes = dmx.src.read_u16le()?; @@ -355,19 +413,34 @@ fn parse_strf_vids(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize let xdpi = dmx.src.read_u32le()?; let ydpi = dmx.src.read_u32le()?; let colors = dmx.src.read_u32le()?; + validate!(colors <= 256); let imp_colors = dmx.src.read_u32le()?; let flip = height < 0; let format = if bitcount > 8 { RGB24_FORMAT } else { PAL8_FORMAT }; - let vhdr = NAVideoInfo::new(width as usize, if flip { -height as usize } else { height as usize}, flip, PAL8_FORMAT); + let mut vhdr = NAVideoInfo::new(width as usize, if flip { -height as usize } else { height as usize}, flip, format); + vhdr.bits = (planes as u8) * (bitcount as u8); let vci = NACodecTypeInfo::Video(vhdr); let edata = dmx.read_extradata(size - 40)?; + if colors > 0 { + if let Some(ref buf) = edata { + let mut pal = [0u8; 1024]; + for (dpal, spal) in pal.chunks_mut(4).take(colors as usize).zip(buf.chunks(4)) { + dpal[0] = spal[2]; + dpal[1] = spal[1]; + dpal[2] = spal[0]; + dpal[3] = 0; + } + let pal = PalInfo { pal: Arc::new(pal), changed: true, stream_no: strmgr.get_num_streams() }; + dmx.pal.push(pal); + } + } 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, u32::from(dmx.sstate.strm_no), vinfo, dmx.tb_num, dmx.tb_den)); + let res = strmgr.add_stream(NAStream::new(StreamType::Video, u32::from(dmx.sstate.strm_no), vinfo, dmx.tb_num, dmx.tb_den, u64::from(dmx.strm_duration))); if res.is_none() { return Err(MemoryError); } dmx.sstate.reset(); Ok(size) @@ -385,13 +458,19 @@ fn parse_strf_auds(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize 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 edata = if size > 16 { + let edata_size = dmx.src.read_u16le()? as usize; + validate!(edata_size + 18 <= size); + dmx.read_extradata(size - 18)? + } else { + None + }; 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, u32::from(dmx.sstate.strm_no), ainfo, dmx.tb_num, dmx.tb_den)); + let res = strmgr.add_stream(NAStream::new(StreamType::Audio, u32::from(dmx.sstate.strm_no), ainfo, dmx.tb_num, dmx.tb_den, u64::from(dmx.strm_duration))); if res.is_none() { return Err(MemoryError); } dmx.sstate.reset(); Ok(size) @@ -400,7 +479,7 @@ fn parse_strf_auds(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize fn parse_strf_xxxx(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult { let edata = dmx.read_extradata(size)?; let info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata); - let res = strmgr.add_stream(NAStream::new(StreamType::Data, u32::from(dmx.sstate.strm_no), info, dmx.tb_num, dmx.tb_den)); + let res = strmgr.add_stream(NAStream::new(StreamType::Data, u32::from(dmx.sstate.strm_no), info, dmx.tb_num, dmx.tb_den, u64::from(dmx.strm_duration))); if res.is_none() { return Err(MemoryError); } dmx.sstate.reset(); Ok(size) @@ -435,17 +514,27 @@ fn parse_junk(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> Ok(size) } -fn parse_idx1(src: &mut ByteReader, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex, size: usize, movi_pos: u64) -> DemuxerResult { +#[allow(clippy::verbose_bit_mask)] +fn parse_idx1(src: &mut ByteReader, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex, size: usize, movi_pos: u64, key_offs: &mut Vec) -> DemuxerResult { validate!((size & 15) == 0); let mut tag = [0u8; 4]; let num_entries = size >> 4; let mut counter = [0u64; 100]; + let mut add_offset = 0; + let mut set_offset = false; for _ in 0..num_entries { src.read_buf(&mut tag)?; let flags = src.read_u32le()?; - let offset = src.read_u32le()? as u64; + let mut offset = src.read_u32le()? as u64; let _length = src.read_u32le()?; + if !set_offset && offset < movi_pos { + add_offset = movi_pos - offset; + } + set_offset = true; + + offset += add_offset; + if tag[0] < b'0' || tag[0] > b'9' || tag[1] < b'0' || tag[1] > b'9' { return Err(InvalidData); } @@ -457,12 +546,15 @@ fn parse_idx1(src: &mut ByteReader, strmgr: &mut StreamManager, seek_idx: &mut S let (tb_num, tb_den) = str.get_timebase(); let pts = counter[stream_no]; let time = NATimeInfo::ts_to_time(pts, 1000, tb_num, tb_den); - seek_idx.add_entry(stream_no as u32, SeekEntry { time, pts, pos: offset + movi_pos - 4 }); + validate!(offset >= movi_pos); + seek_idx.add_entry(stream_no as u32, SeekEntry { time, pts, pos: offset }); } + key_offs.push(offset); } } counter[stream_no] += 1; } + key_offs.sort_unstable(); Ok(size) }