X-Git-Url: https://git.nihav.org/?p=nihav.git;a=blobdiff_plain;f=nihav-realmedia%2Fsrc%2Fdemuxers%2Frealmedia.rs;h=74581d934c93774385b144637e03009753d9e6b7;hp=30b0ccd8a295c10223960ce8b7264b0ac68e36da;hb=a480a0de101483d802a11e72d758dae00fa4860a;hpb=6011e20199143f519881660144a4ca95ba77fd2d diff --git a/nihav-realmedia/src/demuxers/realmedia.rs b/nihav-realmedia/src/demuxers/realmedia.rs index 30b0ccd..74581d9 100644 --- a/nihav-realmedia/src/demuxers/realmedia.rs +++ b/nihav-realmedia/src/demuxers/realmedia.rs @@ -53,13 +53,15 @@ impl RMVideoStream { self.frame.resize(frame_size + self.hdr_size, 0); self.frame[0] = (num_slices - 1) as u8; self.frame_pos = 0; - self.add_slice(1, data); + self.add_slice(1, data).unwrap(); } - fn add_slice(&mut self, slice_no: usize, data: &[u8]) { + fn add_slice(&mut self, slice_no: usize, data: &[u8]) -> DemuxerResult<()> { + validate!(self.hdr_size + self.frame_pos + data.len() <= self.frame.len()); self.write_slice_info(slice_no); let dslice = &mut self.frame[self.hdr_size + self.frame_pos..][..data.len()]; dslice.copy_from_slice(data); self.frame_pos += data.len(); + Ok(()) } fn write_slice_info(&mut self, slice_no: usize) { let off = 1 + (slice_no - 1) * 8; @@ -106,7 +108,7 @@ const RM_ILEAVE_VBRS: u32 = mktag!(b"vbrs"); impl RMAudioStream { fn new(iinfo: Option) -> Self { let deint; - let mut buf: Vec; + let buf: Vec; if let Some(info) = iinfo { deint = match info.id { RM_ILEAVE_INT0 => Deinterleaver::None, @@ -123,8 +125,7 @@ impl RMAudioStream { Deinterleaver::Generic | Deinterleaver::Sipro => { let bsize = (info.frame_size as usize) * (info.factor as usize); - buf = Vec::with_capacity(bsize); - buf.resize(bsize, 0u8); + buf = vec![0; bsize]; }, Deinterleaver::VBR => { buf = Vec::new(); @@ -134,7 +135,7 @@ impl RMAudioStream { deint = Deinterleaver::None; buf = Vec::new(); } - RMAudioStream { deint: deint, iinfo: iinfo, buf: buf, sub_packet: 0 } + RMAudioStream { deint, iinfo, buf, sub_packet: 0 } } fn read_apackets(&mut self, queued_packets: &mut Vec, src: &mut ByteReader, stream: NAStreamRef, ts: u32, keyframe: bool, payload_size: usize) -> DemuxerResult { let (tb_num, tb_den) = stream.get_timebase(); @@ -225,7 +226,7 @@ impl RMAudioStream { self.sub_packet = 0; if self.deint == Deinterleaver::Sipro { - sipro_restore(&mut self.buf, factor, fsize); + sipro_restore(&mut self.buf, factor, iinfo.frame_size as usize); } let mut frames_iter = self.buf.chunks(fsize); @@ -350,6 +351,7 @@ impl CommonStreamData { struct RealMediaDemuxer<'a> { src: &'a mut ByteReader<'a>, data_pos: u64, + data_end: u64, next_data: u64, data_ver: u16, num_packets: u32, @@ -357,6 +359,9 @@ struct RealMediaDemuxer<'a> { str_data: CommonStreamData, + data_chunks: Vec<(u64, u32, u16)>, + cur_data_chunk: usize, + queued_pkts: Vec, slice_buf: Vec, } @@ -381,8 +386,7 @@ fn read_14or30(src: &mut ByteReader) -> DemuxerResult<(bool, u32)> { fn read_video_buf(src: &mut ByteReader, stream: NAStreamRef, ts: u32, keyframe: bool, frame_size: usize) -> DemuxerResult { let size = (frame_size as usize) + 9; - let mut vec: Vec = Vec::with_capacity(size); - vec.resize(size, 0); + let mut vec: Vec = vec![0; size]; //v[0] = 0; // 1 slice vec[4] = 1; src.read_buf(&mut vec[9..])?; @@ -408,19 +412,19 @@ fn read_multiple_frame(src: &mut ByteReader, stream: NAStreamRef, keyframe: bool struct RMDemuxCommon {} impl RMDemuxCommon { - fn parse_stream_info(str_data: &mut CommonStreamData, strmgr: &mut StreamManager, stream_no: u32, edata: &Vec) -> DemuxerResult { + fn parse_stream_info(str_data: &mut CommonStreamData, strmgr: &mut StreamManager, stream_no: u32, edata: &[u8], duration: u32) -> DemuxerResult { let mut is_mlti = false; - let mut mr = MemoryReader::new_read(edata.as_slice()); + let mut mr = MemoryReader::new_read(edata); let mut src = ByteReader::new(&mut mr); let tag = src.read_u32be()?; let tag2 = src.peek_u32be()?; //println!("tag1 {:X} tag2 {:X}", tag, tag2); if tag == mktag!('.', 'r', 'a', 0xFD) { - Self::parse_audio_stream(strmgr, &mut str_data.streams, stream_no, &mut src, edata.as_slice())?; + Self::parse_audio_stream(strmgr, &mut str_data.streams, stream_no, &mut src, edata, duration)?; } else if ((tag2 == mktag!('V', 'I', 'D', 'O')) || (tag2 == mktag!('I', 'M', 'A', 'G'))) && ((tag as usize) <= edata.len()) { - Self::parse_video_stream(strmgr, &mut str_data.streams, stream_no, &mut src, edata.as_slice(), tag2)?; + Self::parse_video_stream(strmgr, &mut str_data.streams, stream_no, &mut src, edata, tag2, duration)?; } else if tag == mktag!(b"LSD:") { - let extradata = Some(edata.clone()); + let extradata = Some(edata.to_owned()); src.read_skip(4)?; //version let channels = src.read_u16be()?; @@ -431,7 +435,7 @@ impl RMDemuxCommon { let soniton = NASoniton::new(samp_size as u8, SONITON_FLAG_SIGNED); let ahdr = NAAudioInfo::new(sample_rate, channels as u8, soniton, 1); let nainfo = NACodecInfo::new("ralf", NACodecTypeInfo::Audio(ahdr), extradata); - let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, sample_rate)); + let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, 1000, u64::from(duration))); if res.is_none() { return Err(MemoryError); } let astr = RMAudioStream::new(None); str_data.streams.push(RMStreamType::Audio(astr)); @@ -463,9 +467,9 @@ impl RMDemuxCommon { let stream_no = str_data.mlti_mapper.get_substream_no(); //todo check that all substreams are of the same type"); if tag == mktag!('.', 'r', 'a', 0xFD) { - Self::parse_audio_stream(strmgr, &mut str_data.streams, stream_no, &mut hsrc, hdrsrc)?; + Self::parse_audio_stream(strmgr, &mut str_data.streams, stream_no, &mut hsrc, hdrsrc, duration)?; } else if (tag2 == mktag!('V', 'I', 'D', 'O')) && ((tag as usize) <= hdr_size) { - Self::parse_video_stream(strmgr, &mut str_data.streams, stream_no, &mut hsrc, hdrsrc, tag2)?; + Self::parse_video_stream(strmgr, &mut str_data.streams, stream_no, &mut hsrc, hdrsrc, tag2, duration)?; } else { println!("unknown MLTI substream {:08X} / {:08X}", tag, tag2); return Err(DemuxerError::InvalidData); @@ -478,7 +482,7 @@ println!("unknown MLTI substream {:08X} / {:08X}", tag, tag2); } Ok(is_mlti) } - fn parse_audio_stream(strmgr: &mut StreamManager, streams: &mut Vec, stream_no: u32, src: &mut ByteReader, edata_: &[u8]) -> DemuxerResult<()> { + fn parse_audio_stream(strmgr: &mut StreamManager, streams: &mut Vec, stream_no: u32, src: &mut ByteReader, edata_: &[u8], duration: u32) -> DemuxerResult<()> { let ver = src.read_u16be()?; let ainfo = match ver { 3 => { @@ -512,8 +516,9 @@ println!(" got ainfo {:?}", ainfo); let eslice = &edata_[(src.tell() as usize)..]; Some(eslice.to_vec()) }; + let duration = if duration == 0 { ainfo.get_duration(1000) } else { u64::from(duration) }; let nainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata); - let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, srate)); + let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, 1000, duration)); if res.is_none() { return Err(MemoryError); } let astr = RMAudioStream::new(ainfo.ileave_info); @@ -521,7 +526,7 @@ println!(" got ainfo {:?}", ainfo); Ok(()) } #[allow(unused_variables)] - fn parse_video_stream(strmgr: &mut StreamManager, streams: &mut Vec, stream_no: u32, src: &mut ByteReader, edata_: &[u8], tag2: u32) -> DemuxerResult<()> { + fn parse_video_stream(strmgr: &mut StreamManager, streams: &mut Vec, stream_no: u32, src: &mut ByteReader, edata_: &[u8], tag2: u32, duration: u32) -> DemuxerResult<()> { src.read_skip(4)?; let fcc = src.read_u32be()?; let width = src.read_u16be()? as usize; @@ -529,11 +534,11 @@ println!(" got ainfo {:?}", ainfo); let bpp = src.read_u16be()?; let pad_w = src.read_u16be()?; let pad_h = src.read_u16be()?; - let fps; + let _fps; if tag2 == mktag!('V', 'I', 'D', 'O') { - fps = src.read_u32be()?; + _fps = src.read_u32be()?; } else { - fps = 0x10000; + _fps = 0x10000; } let extradata: Option>; if src.left() > 0 { @@ -546,7 +551,7 @@ println!(" got ainfo {:?}", ainfo); let vhdr = NAVideoInfo::new(width, height, false, RGB24_FORMAT); let vinfo = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), extradata); - let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no as u32, vinfo, 0x10000, fps)); + let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no as u32, vinfo, 1, 1000, u64::from(duration))); if res.is_none() { return Err(DemuxerError::MemoryError); } let vstr = RMVideoStream::new(); @@ -578,7 +583,7 @@ println!(" got ainfo {:?}", ainfo); if packet_num == 1 { vstr.start_slice(num_pkts, frame_size as usize, slice_buf.as_slice()); } else { - vstr.add_slice(packet_num as usize, slice_buf.as_slice()); + vstr.add_slice(packet_num as usize, slice_buf.as_slice())?; } if (packet_num as usize) < num_pkts { return Err(DemuxerError::TryAgain); @@ -608,7 +613,7 @@ println!(" got ainfo {:?}", ainfo); if packet_num == 1 && frame_size == tail_size { vstr.start_slice(num_pkts, frame_size as usize, slice_buf.as_slice()); } else { - vstr.add_slice(packet_num as usize, slice_buf.as_slice()); + vstr.add_slice(packet_num as usize, slice_buf.as_slice())?; } while src.tell() < pos + (payload_size as u64) { @@ -648,9 +653,8 @@ println!(" got ainfo {:?}", ainfo); } impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> { - #[allow(unused_variables)] - fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> { - self.read_header(strmgr)?; + fn open(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()> { + self.read_header(strmgr, seek_idx)?; Ok(()) } @@ -661,12 +665,16 @@ impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> { return Ok(pkt); } loop { - if self.cur_packet >= self.num_packets { - if (self.next_data != 0) && (self.next_data == self.src.tell()) { + if (self.cur_packet >= self.num_packets) || (self.src.tell() >= self.data_end) { + self.cur_data_chunk += 1; + if self.cur_data_chunk < self.data_chunks.len() { + let (pos, _, _) = self.data_chunks[self.cur_data_chunk]; + self.src.seek(SeekFrom::Start(pos))?; let res = read_chunk(self.src); if let Ok((id, size, ver)) = res { self.data_pos = self.src.tell(); self.data_ver = ver; + self.data_end = self.data_pos + (size as u64); if self.parse_data_start().is_ok() { continue; } @@ -733,9 +741,36 @@ impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> { } #[allow(unused_variables)] - fn seek(&mut self, time: u64) -> DemuxerResult<()> { - Err(NotImplemented) + fn seek(&mut self, time: NATimePoint, seek_idx: &SeekIndex) -> DemuxerResult<()> { + self.queued_pkts.clear(); + let ret = seek_idx.find_pos(time); + if ret.is_none() { + return Err(DemuxerError::SeekError); + } + let ret = ret.unwrap(); + let seek_pos = ret.pos; + for (pos, size, ver) in self.data_chunks.iter() { + if seek_pos < *pos { continue; } + let end = *pos + (*size as u64); + if seek_pos < end { + self.cur_packet = 0; + self.data_pos = seek_pos; + self.data_ver = *ver; + self.data_end = end; + self.src.seek(SeekFrom::Start(seek_pos))?; + return Ok(()); + } + } + Err(DemuxerError::SeekError) } + + fn get_duration(&self) -> u64 { 0 } +} + +impl<'a> NAOptionHandler for RealMediaDemuxer<'a> { + fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } + fn set_options(&mut self, _options: &[NAOption]) { } + fn query_option_value(&self, _name: &str) -> Option { None } } fn read_chunk(src: &mut ByteReader) -> DemuxerResult<(u32, u32, u16)> { @@ -776,6 +811,16 @@ struct RealAudioInfo { ileave_info: Option } +impl RealAudioInfo { + fn get_duration(&self, base: u32) -> u64 { + if self.bytes_per_minute != 0 { + u64::from(self.total_bytes) * 60 * u64::from(base) / u64::from(self.bytes_per_minute) + } else { + 0 + } + } +} + fn skip_ra_metadata(src: &mut ByteReader) -> DemuxerResult<()> { let title_len = src.read_byte()? as usize; src.read_skip(title_len)?; @@ -809,10 +854,10 @@ fn parse_aformat3(src: &mut ByteReader) -> DemuxerResult { validate!(end - start <= (header_len as u64) + 2); Ok(RealAudioInfo { - fcc: fcc, flavor: flavor, + fcc, flavor, sample_rate: 8000, sample_size: 16, channels: 1, channel_mask: 0, - granularity: granularity, bytes_per_minute: bytes_per_minute, - total_bytes: total_bytes, edata_size: 0, + granularity, bytes_per_minute, + total_bytes, edata_size: 0, ileave_info: None, }) } @@ -862,11 +907,11 @@ fn parse_aformat4(src: &mut ByteReader) -> DemuxerResult { }; Ok(RealAudioInfo { - fcc: fcc, flavor: flavor, - sample_rate: sample_rate, sample_size: sample_size as u16, channels: channels, channel_mask: 0, - granularity: granularity, bytes_per_minute: bytes_per_minute, + fcc, flavor, + sample_rate, sample_size: sample_size as u16, channels, channel_mask: 0, + granularity, bytes_per_minute, total_bytes: total_bytes & 0xFFFFFF, edata_size: 0, - ileave_info: ileave_info, + ileave_info, }) } @@ -912,7 +957,7 @@ unimplemented!("ra5 interleave pattern"); let ileave_info = if is_interleaved != 0 { Some(InterleaveInfo { - id: interleaver_id, factor: ileave_factor, block_size: ileave_block_size, frame_size: frame_size, + id: interleaver_id, factor: ileave_factor, block_size: ileave_block_size, frame_size, }) } else { None @@ -924,11 +969,11 @@ unimplemented!("ra5 interleave pattern"); } Ok(RealAudioInfo { - fcc: fcc, flavor: flavor, - sample_rate: sample_rate, sample_size: sample_size as u16, channels: channels, channel_mask: 0, - granularity: granularity, bytes_per_minute: bytes_per_minute, - total_bytes: total_bytes & 0xFFFFFF, edata_size: edata_size, - ileave_info: ileave_info, + fcc, flavor, + sample_rate, sample_size: sample_size as u16, channels, channel_mask: 0, + granularity, bytes_per_minute, + total_bytes: total_bytes & 0xFFFFFF, edata_size, + ileave_info, }) } @@ -941,17 +986,20 @@ impl<'a> RealMediaDemuxer<'a> { RealMediaDemuxer { src: io, data_pos: 0, + data_end: 0, next_data: 0, data_ver: 0, num_packets: 0, cur_packet: 0, str_data: CommonStreamData::new(), + data_chunks: Vec::new(), + cur_data_chunk: 0, queued_pkts: Vec::new(), slice_buf: Vec::new(), } } #[allow(unused_variables)] - fn read_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> { + fn read_header(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()> { let (id, size, ver) = read_chunk(self.src)?; validate!((id == mktag!(b".RMF")) || (id == mktag!(b".RMP"))); validate!(size >= RMVB_HDR_SIZE); @@ -990,20 +1038,25 @@ impl<'a> RealMediaDemuxer<'a> { //warn maybe? break; } - let res = self.parse_chunk(strmgr); + let res = self.parse_chunk(strmgr, seek_idx); match res { Ok(last) => { if last { break; } }, Err(DemuxerError::IOError) => { break; }, Err(etype) => { - if self.data_pos == 0 { // data is not found, report error + if self.data_chunks.is_empty() { // data is not found, report error return Err(etype); } }, }; } //println!("now @ {:X} / {}", self.src.tell(), self.data_pos); - validate!(self.data_pos > 0); - self.src.seek(SeekFrom::Start(self.data_pos))?; + validate!(!self.data_chunks.is_empty()); + self.cur_data_chunk = 0; + let (pos, size, ver) = self.data_chunks[self.cur_data_chunk]; + self.data_pos = pos; + self.data_ver = ver; + self.data_end = pos + (size as u64); + self.src.seek(SeekFrom::Start(self.data_pos + 10))?; self.parse_data_start()?; Ok(()) } @@ -1018,15 +1071,21 @@ impl<'a> RealMediaDemuxer<'a> { self.next_data = next_data_hdr as u64; Ok(()) } - fn parse_chunk(&mut self, strmgr: &mut StreamManager) -> DemuxerResult { + fn parse_chunk(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult { let (id, size, ver) = read_chunk(self.src)?; let end_pos = self.src.tell() - 10 + (size as u64); validate!((ver == 0) || (ver == 2)); if id == mktag!(b"CONT") { self.parse_content_desc()?; } else if id == mktag!(b"MDPR") { self.parse_mdpr(strmgr)?; } - else if id == mktag!(b"DATA") { if self.data_pos == 0 { self.data_ver = ver; self.data_pos = self.src.tell(); } } - else if id == mktag!(b"INDX") { /* do nothing for now */ } + else if id == mktag!(b"DATA") { + self.data_chunks.push((self.src.tell() - 10, size, ver)); + } + else if id == mktag!(b"INDX") { + if !seek_idx.skip_index { + self.parse_index(seek_idx, (size as usize) - 10, ver)?; + } + } else if id == 0 { return Ok(true); } else { println!("unknown chunk type {:08X}", id); } @@ -1067,15 +1126,14 @@ impl<'a> RealMediaDemuxer<'a> { //println!("mime = {}", mime); let edata_size = self.src.read_u32be()? as usize; let edata: Option> = if edata_size == 0 { None } else { - let mut edvec: Vec = Vec::with_capacity(edata_size); - edvec.resize(edata_size, 0); + let mut edvec: Vec = vec![0; edata_size]; self.src.read_buf(&mut edvec)?; Some(edvec) }; let mut is_mlti = false; if edata_size > 8 { if let Some(edata_) = edata { - is_mlti = RMDemuxCommon::parse_stream_info(&mut self.str_data, strmgr, stream_no, &edata_)?; + is_mlti = RMDemuxCommon::parse_stream_info(&mut self.str_data, strmgr, stream_no, &edata_, duration)?; } } else { self.str_data.streams.push(RMStreamType::Unknown); @@ -1086,6 +1144,38 @@ impl<'a> RealMediaDemuxer<'a> { Ok(()) } + fn parse_index(&mut self, seek_idx: &mut SeekIndex, chunk_size: usize, ver: u16) -> DemuxerResult<()> { + if ver != 0 && ver != 2 { return Ok(()); } + let num_entries = self.src.read_u32be()? as usize; + let str_id = self.src.read_u16be()? as u32; + let _next_idx = self.src.read_u32be()?; + if ver == 2 { + self.src.read_u32be()?; + } + if ver == 0 { + validate!(chunk_size == num_entries * 14 + 10); + } else { + validate!(chunk_size == num_entries * 18 + 14); + } + if num_entries == 0 { return Ok(()); } + + seek_idx.add_stream(str_id); + let idx = seek_idx.get_stream_index(str_id).unwrap(); + for _ in 0..num_entries { + let iver = self.src.read_u16be()?; + validate!(iver == ver); + let ts = self.src.read_u32be()? as u64; + if ver == 2 { + self.src.read_u32be()?; + } + let pos = self.src.read_u32be()? as u64; + let _pkt_no = self.src.read_u32be()?; + idx.add_entry(SeekEntry { time: ts, pts: 0, pos }); + } + idx.filled = true; + seek_idx.mode = SeekIndexMode::Present; + Ok(()) + } } fn read_string_size(src: &mut ByteReader, size: usize) -> DemuxerResult { @@ -1113,7 +1203,7 @@ struct RealAudioDemuxer<'a> { impl<'a> DemuxCore<'a> for RealAudioDemuxer<'a> { #[allow(unused_variables)] - fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> { + fn open(&mut self, strmgr: &mut StreamManager, _seek_idx: &mut SeekIndex) -> DemuxerResult<()> { let magic = self.src.read_u32be()?; validate!(magic == mktag!(b".ra\xFD")); let ver = self.src.read_u16be()?; @@ -1146,13 +1236,12 @@ println!(" got ainfo {:?}", ainfo); let extradata = if ainfo.edata_size == 0 { None } else { - let mut dta: Vec = Vec::with_capacity(ainfo.edata_size as usize); - dta.resize(ainfo.edata_size as usize, 0); + let mut dta: Vec = vec![0; ainfo.edata_size as usize]; self.src.read_buf(dta.as_mut_slice())?; Some(dta) }; let nainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata); - let res = strmgr.add_stream(NAStream::new(StreamType::Audio, 0, nainfo, 1, srate)); + let res = strmgr.add_stream(NAStream::new(StreamType::Audio, 0, nainfo, 1, srate, ainfo.get_duration(ainfo.sample_rate))); if res.is_none() { return Err(MemoryError); } let astr = RMAudioStream::new(ainfo.ileave_info); @@ -1187,9 +1276,17 @@ println!(" got ainfo {:?}", ainfo); } #[allow(unused_variables)] - fn seek(&mut self, time: u64) -> DemuxerResult<()> { + fn seek(&mut self, time: NATimePoint, seek_idx: &SeekIndex) -> DemuxerResult<()> { Err(NotImplemented) } + + fn get_duration(&self) -> u64 { 0 } +} + +impl<'a> NAOptionHandler for RealAudioDemuxer<'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> RealAudioDemuxer<'a> { @@ -1220,8 +1317,7 @@ enum IVRRecord { impl IVRRecord { fn read_string(src: &mut ByteReader) -> DemuxerResult> { let len = src.read_u32be()? as usize; - let mut val = Vec::with_capacity(len); - val.resize(len, 0); + let mut val = vec![0; len]; src.read_buf(val.as_mut_slice())?; Ok(val) } @@ -1252,8 +1348,7 @@ impl IVRRecord { 4 => { let name = Self::read_string(src)?; let len = src.read_u32be()? as usize; - let mut val = Vec::with_capacity(len); - val.resize(len, 0); + let mut val = vec![0; len]; src.read_buf(val.as_mut_slice())?; Ok(IVRRecord::BinaryData(name, val)) }, @@ -1315,7 +1410,7 @@ impl RecordDemuxer { RecordDemuxer { start_pos: pos, cur_pos: pos, - start_str: start_str, + start_str, remap_ids: Vec::new(), } } @@ -1340,6 +1435,7 @@ impl RecordDemuxer { cur_str_no += 1; let mut parsed = false; let mut real_stream_no = 0; + let mut duration = 0; for _ in 0..num { let rec = IVRRecord::read(src)?; //println!(" strm property {}", rec); @@ -1348,11 +1444,14 @@ impl RecordDemuxer { if name == b"StreamNumber\0" { real_stream_no = val; } + if name == b"Duration\0" { + duration = val; + } }, IVRRecord::BinaryData(ref name, ref val) => { if name == b"OpaqueData\0" { validate!(!parsed); - let is_mlti = RMDemuxCommon::parse_stream_info(str_data, strmgr, stream_no, val)?; + let is_mlti = RMDemuxCommon::parse_stream_info(str_data, strmgr, stream_no, val, duration)?; if !is_mlti { str_data.str_ids.push(stream_no); } @@ -1405,7 +1504,7 @@ impl RecordDemuxer { loop { let rec = IVRRecord::read(src)?; match rec { - IVRRecord::Packet { ts, str, flags, len, checksum: _ } => { + IVRRecord::Packet { ts, str, flags, len, .. } => { let payload_size = len; let sr = self.remap_ids.iter().position(|x| *x == str); validate!(sr.is_some()); @@ -1456,7 +1555,7 @@ struct RealIVRDemuxer<'a> { impl<'a> DemuxCore<'a> for RealIVRDemuxer<'a> { #[allow(unused_variables)] - fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> { + fn open(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()> { let magic = self.src.peek_u32be()?; if magic == mktag!(b".REC") { let mut rec = RecordDemuxer::new(0, 0); @@ -1528,9 +1627,17 @@ println!("R1M kind"); } #[allow(unused_variables)] - fn seek(&mut self, time: u64) -> DemuxerResult<()> { + fn seek(&mut self, time: NATimePoint, seek_idx: &SeekIndex) -> DemuxerResult<()> { Err(NotImplemented) } + + fn get_duration(&self) -> u64 { 0 } +} + +impl<'a> NAOptionHandler for RealIVRDemuxer<'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> RealIVRDemuxer<'a> { @@ -1618,7 +1725,8 @@ mod test { let mut br = ByteReader::new(&mut fr); let mut dmx = RealMediaDemuxer::new(&mut br); let mut sm = StreamManager::new(); - dmx.open(&mut sm).unwrap(); + let mut si = SeekIndex::new(); + dmx.open(&mut sm, &mut si).unwrap(); loop { let pktres = dmx.get_frame(&mut sm); @@ -1640,7 +1748,8 @@ mod test { let mut br = ByteReader::new(&mut fr); let mut dmx = RealAudioDemuxer::new(&mut br); let mut sm = StreamManager::new(); - dmx.open(&mut sm).unwrap(); + let mut si = SeekIndex::new(); + dmx.open(&mut sm, &mut si).unwrap(); loop { let pktres = dmx.get_frame(&mut sm); @@ -1661,7 +1770,8 @@ mod test { let mut br = ByteReader::new(&mut fr); let mut dmx = RealIVRDemuxer::new(&mut br); let mut sm = StreamManager::new(); - dmx.open(&mut sm).unwrap(); + let mut si = SeekIndex::new(); + dmx.open(&mut sm, &mut si).unwrap(); loop { let pktres = dmx.get_frame(&mut sm);