X-Git-Url: https://git.nihav.org/?a=blobdiff_plain;f=nihav-realmedia%2Fsrc%2Fdemuxers%2Frealmedia.rs;h=6335c6d9b426730ef7c84d6e20621ad3b5c0faad;hb=e614e5e611a4ae6769a0da7cbccec5842b3dbd0f;hp=7a59f567d1e7c83c67346a53d340869955f8307e;hpb=886cde4847280b96e10d240c2f2d76abec121dc8;p=nihav.git diff --git a/nihav-realmedia/src/demuxers/realmedia.rs b/nihav-realmedia/src/demuxers/realmedia.rs index 7a59f56..6335c6d 100644 --- a/nihav-realmedia/src/demuxers/realmedia.rs +++ b/nihav-realmedia/src/demuxers/realmedia.rs @@ -13,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 ], @@ -138,8 +152,7 @@ impl RMAudioStream { 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(); - 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); if keyframe { self.sub_packet = 0; @@ -154,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 { @@ -175,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 => { @@ -184,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); @@ -200,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 }; @@ -232,7 +245,7 @@ impl RMAudioStream { 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); @@ -391,8 +404,7 @@ fn read_video_buf(src: &mut ByteReader, stream: NAStreamRef, ts: u32, keyframe: 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)) } @@ -404,7 +416,6 @@ fn read_multiple_frame(src: &mut ByteReader, stream: NAStreamRef, keyframe: bool 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) } @@ -418,7 +429,6 @@ impl RMDemuxCommon { 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, duration)?; } else if ((tag2 == mktag!('V', 'I', 'D', 'O')) || (tag2 == mktag!('I', 'M', 'A', 'G'))) && ((tag as usize) <= edata.len()) { @@ -431,7 +441,6 @@ impl RMDemuxCommon { 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); @@ -499,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] @@ -574,7 +586,6 @@ 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; @@ -589,14 +600,12 @@ println!(" got ainfo {:?}", ainfo); 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 @@ -607,7 +616,6 @@ 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 { @@ -622,13 +630,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) { @@ -711,7 +717,6 @@ impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> { let stream_id = self.str_data.get_stream_id(str_no as u32, 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); } @@ -723,7 +728,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; @@ -731,7 +735,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 { @@ -797,6 +801,7 @@ struct InterleaveInfo { } #[derive(Clone,Copy,Debug)] +#[allow(dead_code)] struct RealAudioInfo { fcc: u32, sample_rate: u32, @@ -845,10 +850,15 @@ 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); @@ -1022,10 +1032,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()?; @@ -1049,7 +1056,6 @@ impl<'a> RealMediaDemuxer<'a> { }, }; } -//println!("now @ {:X} / {}", self.src.tell(), 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]; @@ -1120,10 +1126,8 @@ 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![0; edata_size]; @@ -1148,10 +1152,7 @@ impl<'a> RealMediaDemuxer<'a> { 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()?; - } + let _next_idx = self.src.read_size(ver)?; if ver == 0 { validate!(chunk_size == num_entries * 14 + 10); } else { @@ -1165,10 +1166,7 @@ impl<'a> RealMediaDemuxer<'a> { 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 pos = self.src.read_size(ver)?; let _pkt_no = self.src.read_u32be()?; idx.add_entry(SeekEntry { time: ts, pts: 0, pos }); } @@ -1184,8 +1182,7 @@ 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 let Ok(res) = str { + if let Ok(res) = String::from_utf8(vec) { Ok(res) } else { Ok(String::new()) @@ -1209,20 +1206,19 @@ impl<'a> DemuxCore<'a> for RealAudioDemuxer<'a> { 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 @@ -1255,7 +1251,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) { @@ -1265,10 +1262,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; } } @@ -1305,7 +1305,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), @@ -1331,12 +1331,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()?; 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)?; @@ -1370,10 +1370,7 @@ impl IVRRecord { } } fn is_data_start(&self) -> bool { - match *self { - IVRRecord::DataStart => true, - _ => false, - } + matches!(*self, IVRRecord::DataStart) } } @@ -1383,8 +1380,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) => @@ -1422,7 +1419,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; @@ -1438,7 +1434,6 @@ impl RecordDemuxer { 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" { @@ -1475,16 +1470,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)?; @@ -1504,9 +1496,9 @@ impl RecordDemuxer { loop { let rec = IVRRecord::read(src)?; match rec { - IVRRecord::Packet { ts, str, flags, len, .. } => { + 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; @@ -1559,13 +1551,12 @@ impl<'a> DemuxCore<'a> for RealIVRDemuxer<'a> { 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()?; @@ -1574,7 +1565,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()?; @@ -1586,7 +1576,7 @@ println!("R1M kind"); 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))?; @@ -1617,7 +1607,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 {