});
}
+trait ReadSize {
+ fn read_size(&mut self, ver: u16) -> ByteIOResult<u64>;
+}
+
+impl<'a> ReadSize for ByteReader<'a> {
+ fn read_size(&mut self, ver: u16) -> ByteIOResult<u64> {
+ 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 ],
}
}
fn flush(&mut self) {
- self.frame.truncate(0);
+ self.frame.clear();
self.frame_size = 0;
self.frame_pos = 0;
}
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;
impl RMAudioStream {
fn new(iinfo: Option<InterleaveInfo>) -> Self {
let deint;
- let mut buf: Vec<u8>;
+ let buf: Vec<u8>;
if let Some(info) = iinfo {
deint = match info.id {
RM_ILEAVE_INT0 => Deinterleaver::None,
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();
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<NAPacket>, src: &mut ByteReader, stream: Rc<NAStream>, ts: u32, keyframe: bool, payload_size: usize) -> DemuxerResult<NAPacket> {
- 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<NAPacket>, src: &mut ByteReader, stream: NAStreamRef, ts: u32, keyframe: bool, payload_size: usize) -> DemuxerResult<NAPacket> {
+ let ts = stream.make_ts(Some(ts as u64), None, None);
if keyframe {
self.sub_packet = 0;
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 {
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 => {
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);
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 };
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);
struct RealMediaDemuxer<'a> {
src: &'a mut ByteReader<'a>,
data_pos: u64,
+ data_end: u64,
next_data: u64,
data_ver: u16,
num_packets: u32,
str_data: CommonStreamData,
+ data_chunks: Vec<(u64, u32, u16)>,
+ cur_data_chunk: usize,
+
queued_pkts: Vec<NAPacket>,
slice_buf: Vec<u8>,
}
}
}
-fn read_video_buf(src: &mut ByteReader, stream: Rc<NAStream>, ts: u32, keyframe: bool, frame_size: usize) -> DemuxerResult<NAPacket> {
- let size = (frame_size as usize) + 9;
- let mut vec: Vec<u8> = 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<NAPacket> {
+ let size = frame_size + 9;
+ let mut vec: Vec<u8> = 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<NAStream>, keyframe: bool, skip_mtype: bool) -> DemuxerResult<NAPacket> {
+fn read_multiple_frame(src: &mut ByteReader, stream: NAStreamRef, keyframe: bool, skip_mtype: bool) -> DemuxerResult<NAPacket> {
if !skip_mtype {
let mtype = src.read_byte()?;
validate!(mtype == 0xC0);
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)
}
struct RMDemuxCommon {}
impl RMDemuxCommon {
- fn parse_stream_info(str_data: &mut CommonStreamData, strmgr: &mut StreamManager, stream_no: u32, edata: &Vec<u8>) -> DemuxerResult<bool> {
+ fn parse_stream_info(str_data: &mut CommonStreamData, strmgr: &mut StreamManager, stream_no: u32, edata: &[u8], duration: u32) -> DemuxerResult<bool> {
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));
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);
}
Ok(is_mlti)
}
- fn parse_audio_stream(strmgr: &mut StreamManager, streams: &mut Vec<RMStreamType>, stream_no: u32, src: &mut ByteReader, edata_: &[u8]) -> DemuxerResult<()> {
+ fn parse_audio_stream(strmgr: &mut StreamManager, streams: &mut Vec<RMStreamType>, stream_no: u32, src: &mut ByteReader, edata_: &[u8], duration: u32) -> DemuxerResult<()> {
let ver = src.read_u16be()?;
let ainfo = match ver {
3 => {
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]
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);
Ok(())
}
#[allow(unused_variables)]
- fn parse_video_stream(strmgr: &mut StreamManager, streams: &mut Vec<RMStreamType>, stream_no: u32, src: &mut ByteReader, edata_: &[u8], tag2: u32) -> DemuxerResult<()> {
+ fn parse_video_stream(strmgr: &mut StreamManager, streams: &mut Vec<RMStreamType>, 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;
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<Vec<u8>>;
if src.left() > 0 {
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();
Ok(())
}
#[allow(unused_variables)]
- fn parse_packet_payload(src: &mut ByteReader, rmstream: &mut RMStreamType, stream: Rc<NAStream>, slice_buf: &mut Vec<u8>, queued_pkts: &mut Vec<NAPacket>, keyframe: bool, ts: u32, payload_size: usize) -> DemuxerResult<NAPacket> {
+ #[allow(clippy::question_mark)]
+ fn parse_packet_payload(src: &mut ByteReader, rmstream: &mut RMStreamType, stream: NAStreamRef, slice_buf: &mut Vec<u8>, queued_pkts: &mut Vec<NAPacket>, keyframe: bool, ts: u32, payload_size: usize) -> DemuxerResult<NAPacket> {
match rmstream {
RMStreamType::Video(ref mut vstr) => {
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
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) {
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) {
}
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(())
}
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;
}
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);
}
continue;
}
let stream = streamres.unwrap();
-//println!(" stream {}", str_id);
if strmgr.is_ignored_id(stream_id) {
self.src.read_skip(payload_size)?;
continue;
//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 {
}
#[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<NAValue> { None }
}
fn read_chunk(src: &mut ByteReader) -> DemuxerResult<(u32, u32, u16)> {
}
#[derive(Clone,Copy,Debug)]
+#[allow(dead_code)]
struct RealAudioInfo {
fcc: u32,
sample_rate: u32,
ileave_info: Option<InterleaveInfo>
}
+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)?;
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,
})
}
};
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,
})
}
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
}
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,
})
}
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);
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()?;
//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(())
}
self.next_data = next_data_hdr as u64;
Ok(())
}
- fn parse_chunk(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<bool> {
+ fn parse_chunk(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<bool> {
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); }
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<Vec<u8>> = if edata_size == 0 { None } else {
- let mut edvec: Vec<u8> = Vec::with_capacity(edata_size);
- edvec.resize(edata_size, 0);
+ let mut edvec: Vec<u8> = 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);
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<String> {
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())
}
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
let extradata = if ainfo.edata_size == 0 {
None
} else {
- let mut dta: Vec<u8> = Vec::with_capacity(ainfo.edata_size as usize);
- dta.resize(ainfo.edata_size as usize, 0);
+ let mut dta: Vec<u8> = 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);
fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
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) {
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;
}
}
}
#[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<NAValue> { None }
}
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<u8>, u32),
BinaryData(Vec<u8>, Vec<u8>),
StringData(Vec<u8>, Vec<u8>),
impl IVRRecord {
fn read_string(src: &mut ByteReader) -> DemuxerResult<Vec<u8>> {
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)
}
},
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()?;
validate!((len > 0) && (len < (1 << 24)));
- Ok(IVRRecord::Packet { ts, str, flags, len, checksum: chk })
+ Ok(IVRRecord::Packet { ts, strm, flags, len, checksum: chk })
},
3 => {
let name = Self::read_string(src)?;
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))
},
}
}
fn is_data_start(&self) -> bool {
- match *self {
- IVRRecord::DataStart => true,
- _ => false,
- }
+ matches!(*self, IVRRecord::DataStart)
}
}
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) =>
RecordDemuxer {
start_pos: pos,
cur_pos: pos,
- start_str: start_str,
+ start_str,
remap_ids: Vec::new(),
}
}
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;
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);
}
_ => {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)?;
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 pkt_grp = ((flags >> 8) & 0xFF) as u16;
- let stream_id = str_data.get_stream_id(str_no as u32, pkt_grp);
+ 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)?;
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()?;
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()?;
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(&mut self.src, strmgr, &mut self.str_data)?;
+ rec.parse_header(self.src, strmgr, &mut self.str_data)?;
self.recs.push(rec);
}
self.src.seek(SeekFrom::Start(pos + len))?;
}
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 {
}
#[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<NAValue> { None }
}
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"),
(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"),
pub struct RealMediaDemuxerCreator { }
impl DemuxerCreator for RealMediaDemuxerCreator {
- fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
+ fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
Box::new(RealMediaDemuxer::new(br))
}
fn get_name(&self) -> &'static str { "realmedia" }
pub struct RealAudioDemuxerCreator { }
impl DemuxerCreator for RealAudioDemuxerCreator {
- fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
+ fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
Box::new(RealAudioDemuxer::new(br))
}
fn get_name(&self) -> &'static str { "realaudio" }
pub struct RealIVRDemuxerCreator { }
impl DemuxerCreator for RealIVRDemuxerCreator {
- fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
+ fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
Box::new(RealIVRDemuxer::new(br))
}
fn get_name(&self) -> &'static str { "real_ivr" }
#[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();
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);
}
#[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();
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);
}
#[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();
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);