X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-realmedia%2Fsrc%2Fdemuxers%2Frealmedia.rs;h=7f94cdcf25fa520484160bffb8f292bebc0316b8;hb=e6aaad5c5273cd814b5748b7faf3751835a37217;hp=22d964e7588d53659916cb3aea90632a75d16143;hpb=5641dccfbf2a70d589cf094a0d4ed5a10f919f00;p=nihav.git diff --git a/nihav-realmedia/src/demuxers/realmedia.rs b/nihav-realmedia/src/demuxers/realmedia.rs index 22d964e..7f94cdc 100644 --- a/nihav-realmedia/src/demuxers/realmedia.rs +++ b/nihav-realmedia/src/demuxers/realmedia.rs @@ -1,8 +1,5 @@ use super::*; use nihav_core::demuxers::DemuxerError::*; -use nihav_core::io::byteio::*; -use nihav_core::frame::*; -use nihav_core::formats::*; use std::io::SeekFrom; use std::mem; use std::fmt; @@ -16,6 +13,20 @@ macro_rules! mktag { }); } +trait ReadSize { + fn read_size(&mut self, ver: u16) -> ByteIOResult; +} + +impl<'a> ReadSize for ByteReader<'a> { + fn read_size(&mut self, ver: u16) -> ByteIOResult { + match ver { + 0 => Ok(u64::from(self.read_u32be()?)), + 2 => self.read_u64be(), + _ => unreachable!(), + } + } +} + const RM_SIPRO_BLOCK_SIZES: [usize; 4] = [ 29, 19, 37, 20 ]; const RM_SIPRO_SWAPS: [[u8; 2]; 38] = [ [ 0, 63 ], [ 1, 22 ], [ 2, 44 ], [ 3, 90 ], @@ -47,7 +58,7 @@ impl RMVideoStream { } } fn flush(&mut self) { - self.frame.truncate(0); + self.frame.clear(); self.frame_size = 0; self.frame_pos = 0; } @@ -56,13 +67,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; @@ -109,7 +122,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, @@ -126,8 +139,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(); @@ -137,11 +149,10 @@ 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: Rc, ts: u32, keyframe: bool, payload_size: usize) -> DemuxerResult { - let (tb_num, tb_den) = stream.get_timebase(); - let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den); + fn read_apackets(&mut self, queued_packets: &mut Vec, src: &mut ByteReader, stream: NAStreamRef, ts: u32, keyframe: bool, payload_size: usize) -> DemuxerResult { + let ts = stream.make_ts(Some(ts as u64), None, None); if keyframe { self.sub_packet = 0; @@ -156,8 +167,8 @@ impl RMAudioStream { let bsize = iinfo.block_size as usize; let ppos = self.sub_packet; for sb in 0..halffact { - let mut dst = &mut self.buf[sb * 2 * fsize + ppos * bsize..][..bsize]; - src.read_buf(&mut dst)?; + let dst = &mut self.buf[sb * 2 * fsize + ppos * bsize..][..bsize]; + src.read_buf(dst)?; } self.sub_packet += 1; if self.sub_packet == factor { @@ -177,8 +188,8 @@ impl RMAudioStream { for sb in 0..factor2 { let sb_pos = factor * sb + ((factor + 1) >> 1) * (ppos & 1) + (ppos >> 1); - let mut dst = &mut self.buf[bsize * sb_pos..][..bsize]; - src.read_buf(&mut dst)?; + let dst = &mut self.buf[bsize * sb_pos..][..bsize]; + src.read_buf(dst)?; } }, Deinterleaver::Sipro => { @@ -186,8 +197,8 @@ impl RMAudioStream { let fsize = iinfo.frame_size as usize; let ppos = self.sub_packet; - let mut dst = &mut self.buf[fsize * ppos..][..fsize]; - src.read_buf(&mut dst)?; + let dst = &mut self.buf[fsize * ppos..][..fsize]; + src.read_buf(dst)?; }, Deinterleaver::VBR => { validate!(payload_size >= 5); @@ -202,7 +213,7 @@ impl RMAudioStream { sizes.push(sz); } validate!(tot_size + num_entries * 2 + 2 == payload_size); - let pkt_ts = NATimeInfo::new(None, None, None, tb_num, tb_den); + let pkt_ts = stream.make_ts(None, None, None); let mut first = true; for size in sizes.iter() { let cur_ts = if first { ts } else { pkt_ts }; @@ -228,13 +239,13 @@ 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); let pkt0 = frames_iter.next().unwrap(); - let pkt_ts = NATimeInfo::new(None, None, None, tb_num, tb_den); + let pkt_ts = stream.make_ts(None, None, None); for pkts in frames_iter { let pkt = NAPacket::new(stream.clone(), pkt_ts, true, pkts.to_vec()); queued_packets.push(pkt); @@ -353,6 +364,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, @@ -360,6 +372,9 @@ struct RealMediaDemuxer<'a> { str_data: CommonStreamData, + data_chunks: Vec<(u64, u32, u16)>, + cur_data_chunk: usize, + queued_pkts: Vec, slice_buf: Vec, } @@ -382,20 +397,18 @@ fn read_14or30(src: &mut ByteReader) -> DemuxerResult<(bool, u32)> { } } -fn read_video_buf(src: &mut ByteReader, stream: Rc, 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); +fn read_video_buf(src: &mut ByteReader, stream: NAStreamRef, ts: u32, keyframe: bool, frame_size: usize) -> DemuxerResult { + let size = frame_size + 9; + let mut vec: Vec = vec![0; size]; //v[0] = 0; // 1 slice vec[4] = 1; src.read_buf(&mut vec[9..])?; - let (tb_num, tb_den) = stream.get_timebase(); - let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den); + let ts = stream.make_ts(Some(ts as u64), None, None); Ok(NAPacket::new(stream, ts, keyframe, vec)) } -fn read_multiple_frame(src: &mut ByteReader, stream: Rc, keyframe: bool, skip_mtype: bool) -> DemuxerResult { +fn read_multiple_frame(src: &mut ByteReader, stream: NAStreamRef, keyframe: bool, skip_mtype: bool) -> DemuxerResult { if !skip_mtype { let mtype = src.read_byte()?; validate!(mtype == 0xC0); @@ -403,7 +416,6 @@ fn read_multiple_frame(src: &mut ByteReader, stream: Rc, keyframe: boo let (_, frame_size) = read_14or30(src)?; let (_, timestamp) = read_14or30(src)?; let _seq_no = src.read_byte()?; -//println!(" multiple frame size {} ts {} seq {}", frame_size, timestamp, seq_no); read_video_buf(src, stream, timestamp, keyframe, frame_size as usize) } @@ -411,30 +423,28 @@ fn read_multiple_frame(src: &mut ByteReader, stream: Rc, keyframe: boo 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()?; let samp_size = src.read_u16be()?; let sample_rate = src.read_u32be()?; - println!("LSD sr {}, {} ch", sample_rate, channels); 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, 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)); @@ -466,9 +476,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); @@ -481,7 +491,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 => { @@ -498,10 +508,13 @@ println!("unknown MLTI substream {:08X} / {:08X}", tag, tag2); return Err(DemuxerError::InvalidData); }, }; -println!(" got ainfo {:?}", ainfo); let cname = find_codec_name(RM_AUDIO_CODEC_REGISTER, ainfo.fcc); let blk_size = if ainfo.fcc != mktag!(b"sipr") { - ainfo.granularity as usize + if let Some(ref iinfo) = ainfo.ileave_info { + iinfo.block_size as usize + } else { + ainfo.granularity as usize + } } else { validate!(ainfo.flavor <= 3); RM_SIPRO_BLOCK_SIZES[ainfo.flavor as usize] @@ -515,8 +528,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, nainfo, 1, 1000, duration)); if res.is_none() { return Err(MemoryError); } let astr = RMAudioStream::new(ainfo.ileave_info); @@ -524,7 +538,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; @@ -532,11 +546,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 { @@ -549,7 +563,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, vinfo, 1, 1000, u64::from(duration))); if res.is_none() { return Err(DemuxerError::MemoryError); } let vstr = RMVideoStream::new(); @@ -557,7 +571,8 @@ println!(" got ainfo {:?}", ainfo); Ok(()) } #[allow(unused_variables)] - fn parse_packet_payload(src: &mut ByteReader, rmstream: &mut RMStreamType, stream: Rc, slice_buf: &mut Vec, queued_pkts: &mut Vec, keyframe: bool, ts: u32, payload_size: usize) -> DemuxerResult { + #[allow(clippy::question_mark)] + fn parse_packet_payload(src: &mut ByteReader, rmstream: &mut RMStreamType, stream: NAStreamRef, slice_buf: &mut Vec, queued_pkts: &mut Vec, keyframe: bool, ts: u32, payload_size: usize) -> DemuxerResult { match rmstream { RMStreamType::Video(ref mut vstr) => { @@ -572,29 +587,26 @@ println!(" got ainfo {:?}", ainfo); let (_, frame_size) = read_14or30(src)?; let (_, off) = read_14or30(src)?; let seq_no = src.read_byte()?; -//println!(" mode 0 pkt {}/{} off {}/{} seq {}", packet_num, num_pkts, off, frame_size, seq_no); let hdr_skip = (src.tell() - pos) as usize; - let slice_size = (payload_size - hdr_skip) as usize; + let slice_size = payload_size - hdr_skip; slice_buf.resize(slice_size, 0); src.read_buf(slice_buf.as_mut_slice())?; 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); } //todo: check if full frame is received - let (tb_num, tb_den) = stream.get_timebase(); - let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den); + let ts = stream.make_ts(Some(ts as u64), None, None); let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data()); Ok(pkt) }, 1 => { // whole frame let seq_no = src.read_byte()?; -//println!(" mode 1 seq {}", seq_no); read_video_buf(src, stream, ts, keyframe, payload_size - 2) }, 2 => { // last partial frame @@ -605,13 +617,12 @@ println!(" got ainfo {:?}", ainfo); let (_, frame_size) = read_14or30(src)?; let (_, tail_size) = read_14or30(src)?; let seq_no = src.read_byte()?; -//println!(" mode 2 pkt {}/{} tail {}/{} seq {}", packet_num, num_pkts, tail_size, frame_size, seq_no); slice_buf.resize(tail_size as usize, 0); src.read_buf(slice_buf.as_mut_slice())?; 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) { @@ -620,13 +631,11 @@ println!(" got ainfo {:?}", ainfo); queued_pkts.push(res.unwrap()); } queued_pkts.reverse(); - let (tb_num, tb_den) = stream.get_timebase(); - let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den); + let ts = stream.make_ts(Some(ts as u64), None, None); let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data()); Ok(pkt) }, _ => { // multiple frames -//println!(" mode 3"); let res = read_multiple_frame(src, stream.clone(), keyframe, true); if res.is_err() { return res; } while src.tell() < pos + (payload_size as u64) { @@ -651,9 +660,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(()) } @@ -664,12 +672,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; } @@ -703,10 +715,9 @@ impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> { let payload_size = len - (hdr_size as usize); - let stream_id = self.str_data.get_stream_id(str_no as u32, pkt_grp); + let stream_id = self.str_data.get_stream_id(str_no, pkt_grp); let sr = self.str_data.find_stream(stream_id); if sr.is_none() { -//println!("stream {} not found", str_no); self.src.read_skip(payload_size)?; return Err(DemuxerError::InvalidData); } @@ -718,7 +729,6 @@ impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> { continue; } let stream = streamres.unwrap(); -//println!(" stream {}", str_id); if strmgr.is_ignored_id(stream_id) { self.src.read_skip(payload_size)?; continue; @@ -726,7 +736,7 @@ impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> { //todo skip unwanted packet let keyframe = (flags & KEYFRAME_FLAG) != 0; - let ret = RMDemuxCommon::parse_packet_payload(&mut self.src, &mut self.str_data.streams[str_id], stream, &mut self.slice_buf, &mut self.queued_pkts, keyframe, ts, payload_size); + let ret = RMDemuxCommon::parse_packet_payload(self.src, &mut self.str_data.streams[str_id], stream, &mut self.slice_buf, &mut self.queued_pkts, keyframe, ts, payload_size); if let Err(DemuxerError::TryAgain) = ret { continue; } else { @@ -736,9 +746,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)> { @@ -765,6 +802,7 @@ struct InterleaveInfo { } #[derive(Clone,Copy,Debug)] +#[allow(dead_code)] struct RealAudioInfo { fcc: u32, sample_rate: u32, @@ -779,6 +817,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)?; @@ -803,19 +851,24 @@ fn parse_aformat3(src: &mut ByteReader) -> DemuxerResult { skip_ra_metadata(src)?; - let _can_copy = src.read_byte()?; - let fcc_len = src.read_byte()?; - validate!(fcc_len == 4); - let fcc = src.read_u32be()?; + // the original RealAudio has no such fields + let fcc = if src.tell() != start + u64::from(header_len) + 2 { + let _can_copy = src.read_byte()?; + let fcc_len = src.read_byte()?; + validate!(fcc_len == 0 || fcc_len == 4); + src.read_u32be()? + } else { + read_u32be(b"lpcJ")? + }; let end = src.tell(); 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, }) } @@ -865,11 +918,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, }) } @@ -915,7 +968,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 @@ -927,11 +980,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, }) } @@ -944,17 +997,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); @@ -977,10 +1033,7 @@ impl<'a> RealMediaDemuxer<'a> { let num_pkt = self.src.read_u32be()? as usize; let duration = self.src.read_u32be()?; let preroll = self.src.read_u32be()?; - if ver == 2 { - self.src.read_skip(4)?; - } - let idx_off = self.src.read_u32be()?; + let idx_off = self.src.read_size(ver)?; let data_off = self.src.read_u32be()?; let num_streams = self.src.read_u16be()? as usize; let flags = self.src.read_u16be()?; @@ -993,20 +1046,24 @@ 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(()) } @@ -1021,15 +1078,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); } @@ -1064,21 +1127,18 @@ impl<'a> RealMediaDemuxer<'a> { let duration = self.src.read_u32be()?; let sname_size = self.src.read_byte()? as usize; let sname = read_string_size(self.src, sname_size)?; -//println!("str #{} sname = {} pkts {}/{} start {} preroll {}", stream_no, sname, maxps, avgps, start, preroll); let mime_size = self.src.read_byte()? as usize; let mime = read_string_size(self.src, mime_size)?; -//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); @@ -1089,6 +1149,32 @@ 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_size(ver)?; + 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; + let pos = self.src.read_size(ver)?; + 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 { @@ -1097,9 +1183,8 @@ fn read_string_size(src: &mut ByteReader, size: usize) -> DemuxerResult let c = src.read_byte()?; vec.push(c); } - let str = String::from_utf8(vec); - if str.is_ok() { - Ok(str.unwrap()) + if let Ok(res) = String::from_utf8(vec) { + Ok(res) } else { Ok(String::new()) } @@ -1116,26 +1201,25 @@ 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()?; let ainfo = match ver { 3 => { - parse_aformat3(&mut self.src)? + parse_aformat3(self.src)? }, 4 => { - parse_aformat4(&mut self.src)? + parse_aformat4(self.src)? }, 5 => { - parse_aformat5(&mut self.src)? + parse_aformat5(self.src)? }, _ => { println!("unknown version {}", ver); return Err(DemuxerError::InvalidData); }, }; -println!(" got ainfo {:?}", ainfo); let cname = find_codec_name(RM_AUDIO_CODEC_REGISTER, ainfo.fcc); let blk_size = if ainfo.fcc != mktag!(b"sipr") { ainfo.granularity as usize @@ -1149,13 +1233,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); @@ -1169,7 +1252,8 @@ println!(" got ainfo {:?}", ainfo); fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult { if !self.queued_pkts.is_empty() { - let pkt = self.queued_pkts.pop().unwrap(); + let mut pkt = self.queued_pkts.pop().unwrap(); + pkt.ts.pts = None; return Ok(pkt); } if (self.data_end != 0) && (self.src.tell() >= self.data_end) { @@ -1179,10 +1263,13 @@ println!(" got ainfo {:?}", ainfo); let stream = streamres.unwrap(); if let Some(ref mut astr) = self.stream { loop { - let ret = astr.read_apackets(&mut self.queued_pkts, &mut self.src, stream.clone(), 0, false, self.blk_size); + let mut ret = astr.read_apackets(&mut self.queued_pkts, self.src, stream.clone(), 0, false, self.blk_size); if let Err(DemuxerError::TryAgain) = ret { continue; } + if let Ok(ref mut pkt) = ret { + pkt.ts.pts = None; + } return ret; } } @@ -1190,9 +1277,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> { @@ -1211,7 +1306,7 @@ impl<'a> RealAudioDemuxer<'a> { enum IVRRecord { Invalid(u8), StreamProperties(usize), - Packet { ts: u32, str: u32, flags: u32, len: usize, checksum: u32 }, + Packet { ts: u32, strm: u32, flags: u32, len: usize, checksum: u32 }, IntValue(Vec, u32), BinaryData(Vec, Vec), StringData(Vec, Vec), @@ -1223,8 +1318,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) } @@ -1238,11 +1332,12 @@ impl IVRRecord { }, 2 => { let ts = src.read_u32be()?; - let str = src.read_u16be()? as u32; + let strm = src.read_u16be()? as u32; let flags = src.read_u32be()?; let len = src.read_u32be()? as usize; let chk = src.read_u32be()?; - Ok(IVRRecord::Packet { ts, str, flags, len, checksum: chk }) + validate!((len > 0) && (len < (1 << 24))); + Ok(IVRRecord::Packet { ts, strm, flags, len, checksum: chk }) }, 3 => { let name = Self::read_string(src)?; @@ -1254,8 +1349,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)) }, @@ -1277,10 +1371,7 @@ impl IVRRecord { } } fn is_data_start(&self) -> bool { - match *self { - IVRRecord::DataStart => true, - _ => false, - } + matches!(*self, IVRRecord::DataStart) } } @@ -1290,8 +1381,8 @@ impl fmt::Display for IVRRecord { IVRRecord::Invalid(typ) => write!(f, "Invalid({:02X})", typ), IVRRecord::StreamProperties(num) => write!(f, "({} stream properties)", num), - IVRRecord::Packet { ts, str, flags, len, checksum } => - write!(f, "paket({}, {}, {:X}, {}, {})", ts, str, flags, len, checksum), + IVRRecord::Packet { ts, strm, flags, len, checksum } => + write!(f, "paket({}, {}, {:X}, {}, {})", ts, strm, flags, len, checksum), IVRRecord::IntValue(ref name, val) => write!(f, "({} = {})", String::from_utf8_lossy(name), val), IVRRecord::BinaryData(ref name, ref val) => @@ -1317,7 +1408,7 @@ impl RecordDemuxer { RecordDemuxer { start_pos: pos, cur_pos: pos, - start_str: start_str, + start_str, remap_ids: Vec::new(), } } @@ -1329,7 +1420,6 @@ impl RecordDemuxer { let num_entries = src.read_u32be()? as usize; for _ in 0..num_entries { let _rec = IVRRecord::read(src)?; -//println!(" header rec {}", _rec); } let mut has_seek_table = false; let mut cur_str_no = 0; @@ -1342,19 +1432,22 @@ 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); match rec { IVRRecord::IntValue(ref name, val) => { 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); } @@ -1378,16 +1471,13 @@ impl RecordDemuxer { _ => {println!(" unexpected {}", rec); return Err(DemuxerError::InvalidData); } }; } - println!(" now @ {:X}", src.tell()); let off0 = src.read_u32be()? as u64; let _off1 = src.read_u32be()?; let _off2 = src.read_u32be()?; validate!(off0 + self.start_pos == src.tell()); - println!(" has seek tab: {}", has_seek_table); if has_seek_table { src.read_skip(4)?; let data_off = src.read_u32be()? as u64; - println!(" new off {:X}", data_off); let pos = src.tell(); validate!(data_off + self.start_pos > pos); src.read_skip((data_off + self.start_pos - pos) as usize)?; @@ -1407,12 +1497,13 @@ impl RecordDemuxer { loop { let rec = IVRRecord::read(src)?; match rec { - IVRRecord::Packet { ts, str, flags: _, len, checksum: _ } => { + IVRRecord::Packet { ts, strm, flags, len, .. } => { let payload_size = len; - let sr = self.remap_ids.iter().position(|x| *x == str); + let sr = self.remap_ids.iter().position(|x| *x == strm); validate!(sr.is_some()); let str_no = self.start_str + (sr.unwrap() as u32); - let stream_id = str_data.get_stream_id(str_no as u32, 0/*pkt_grp*/); + let pkt_grp = ((flags >> 8) & 0xFF) as u16; + let stream_id = str_data.get_stream_id(str_no, pkt_grp); let sr = str_data.find_stream(stream_id); if sr.is_none() { src.read_skip(payload_size)?; @@ -1457,17 +1548,16 @@ 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); - rec.parse_header(&mut self.src, strmgr, &mut self.str_data)?; + rec.parse_header(self.src, strmgr, &mut self.str_data)?; self.recs.push(rec); } else if magic == mktag!(b".R1M") { -println!("R1M kind"); self.src.read_skip(4)?; // magic self.src.read_skip(3)?; // always 0, 1, 1 ? - let _name = IVRRecord::read_string(&mut self.src)?; + let _name = IVRRecord::read_string(self.src)?; self.src.read_skip(1)?; // always 0? let len1 = self.src.read_u32be()? as u64; let off1 = self.src.read_u64be()?; @@ -1476,7 +1566,6 @@ println!("R1M kind"); self.src.read_skip((off1 - cpos) as usize)?; loop { let typ = self.src.read_byte()?; - println!(" at {:X} type {:02X}", self.src.tell(), typ); match typ { 1 => { let len = self.src.read_u32be()?; @@ -1485,10 +1574,12 @@ println!("R1M kind"); 2 => { let len = self.src.read_u32be()? as u64; let pos = self.src.tell(); - let num_streams = self.str_data.streams.len() as u32; - let mut rec = RecordDemuxer::new(pos + 12, num_streams); - rec.parse_header(&mut self.src, strmgr, &mut self.str_data)?; - self.recs.push(rec); + if len > 0x20 { + let num_streams = self.str_data.streams.len() as u32; + let mut rec = RecordDemuxer::new(pos + 12, num_streams); + rec.parse_header(self.src, strmgr, &mut self.str_data)?; + self.recs.push(rec); + } self.src.seek(SeekFrom::Start(pos + len))?; }, b'R' => { @@ -1517,7 +1608,7 @@ println!("R1M kind"); } loop { if self.cur_rec >= self.recs.len() { return Err(DemuxerError::EOF); } - let res = self.recs[self.cur_rec].get_packet(&mut self.src, &mut self.str_data, strmgr, &mut self.queued_pkts, &mut self.slice_buf); + let res = self.recs[self.cur_rec].get_packet(self.src, &mut self.str_data, strmgr, &mut self.queued_pkts, &mut self.slice_buf); if let Err(DemuxerError::EOF) = res { self.cur_rec += 1; } else { @@ -1527,9 +1618,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> { @@ -1545,7 +1644,7 @@ impl<'a> RealIVRDemuxer<'a> { } } -static RM_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[ +static RM_VIDEO_CODEC_REGISTER: &[(&[u8;4], &str)] = &[ (b"RV10", "realvideo1"), (b"RV20", "realvideo2"), (b"RVTR", "realvideo2"), @@ -1555,7 +1654,7 @@ static RM_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[ (b"CLV1", "clearvideo_rm"), ]; -static RM_AUDIO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[ +static RM_AUDIO_CODEC_REGISTER: &[(&[u8;4], &str)] = &[ (b"lpcJ", "ra14.4"), (b"28_8", "ra28.8"), (b"cook", "cook"), @@ -1570,7 +1669,7 @@ static RM_AUDIO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[ pub struct RealMediaDemuxerCreator { } impl DemuxerCreator for RealMediaDemuxerCreator { - fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box + 'a> { + fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box + 'a> { Box::new(RealMediaDemuxer::new(br)) } fn get_name(&self) -> &'static str { "realmedia" } @@ -1579,7 +1678,7 @@ impl DemuxerCreator for RealMediaDemuxerCreator { pub struct RealAudioDemuxerCreator { } impl DemuxerCreator for RealAudioDemuxerCreator { - fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box + 'a> { + fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box + 'a> { Box::new(RealAudioDemuxer::new(br)) } fn get_name(&self) -> &'static str { "realaudio" } @@ -1588,7 +1687,7 @@ impl DemuxerCreator for RealAudioDemuxerCreator { pub struct RealIVRDemuxerCreator { } impl DemuxerCreator for RealIVRDemuxerCreator { - fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box + 'a> { + fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box + 'a> { Box::new(RealIVRDemuxer::new(br)) } fn get_name(&self) -> &'static str { "real_ivr" } @@ -1601,6 +1700,7 @@ mod test { #[test] fn test_rm_demux() { + // sample from a private collection let mut file = File::open("assets/RV/rv10_dnet_640x352_realvideo_encoder_4.0.rm").unwrap(); // File::open("assets/RV/rv20_cook_640x352_realproducer_plus_8.51.rm").unwrap(); @@ -1617,7 +1717,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); @@ -1632,6 +1733,7 @@ mod test { } #[test] fn test_ra_demux() { + // sample: https://samples.mplayerhq.hu/real//RA/ra_with_comment_field/diemusik.ra let mut file = // File::open("assets/RV/welcome288.ra").unwrap(); File::open("assets/RV/diemusik.ra").unwrap(); @@ -1639,7 +1741,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); @@ -1653,6 +1756,7 @@ mod test { } #[test] fn test_ivr_demux() { + // sample: https://samples.mplayerhq.hu/real/ivr/Opener_rm_hi.ivr let mut file = File::open("assets/RV/Opener_rm_hi.ivr").unwrap(); // File::open("assets/RV/SherwinWilliamsCommercial.ivr").unwrap(); @@ -1660,7 +1764,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);