2 use nihav_core::demuxers::DemuxerError::*;
8 ($a:expr, $b:expr, $c:expr, $d:expr) => ({
9 (($a as u32) << 24) | (($b as u32) << 16) | (($c as u32) << 8) | ($d as u32)
12 (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
17 fn read_size(&mut self, ver: u16) -> ByteIOResult<u64>;
20 impl<'a> ReadSize for ByteReader<'a> {
21 fn read_size(&mut self, ver: u16) -> ByteIOResult<u64> {
23 0 => Ok(u64::from(self.read_u32be()?)),
24 2 => self.read_u64be(),
30 const RM_SIPRO_BLOCK_SIZES: [usize; 4] = [ 29, 19, 37, 20 ];
31 const RM_SIPRO_SWAPS: [[u8; 2]; 38] = [
32 [ 0, 63 ], [ 1, 22 ], [ 2, 44 ], [ 3, 90 ],
33 [ 5, 81 ], [ 7, 31 ], [ 8, 86 ], [ 9, 58 ],
34 [ 10, 36 ], [ 12, 68 ], [ 13, 39 ], [ 14, 73 ],
35 [ 15, 53 ], [ 16, 69 ], [ 17, 57 ], [ 19, 88 ],
36 [ 20, 34 ], [ 21, 71 ], [ 24, 46 ], [ 25, 94 ],
37 [ 26, 54 ], [ 28, 75 ], [ 29, 50 ], [ 32, 70 ],
38 [ 33, 92 ], [ 35, 74 ], [ 38, 85 ], [ 40, 56 ],
39 [ 42, 87 ], [ 43, 65 ], [ 45, 59 ], [ 48, 79 ],
40 [ 49, 93 ], [ 51, 89 ], [ 55, 95 ], [ 61, 76 ],
41 [ 67, 83 ], [ 77, 80 ]
44 struct RMVideoStream {
65 fn start_slice(&mut self, num_slices: usize, frame_size: usize, data: &[u8]) {
66 self.hdr_size = num_slices * 8 + 1;
67 self.frame.resize(frame_size + self.hdr_size, 0);
68 self.frame[0] = (num_slices - 1) as u8;
70 self.add_slice(1, data).unwrap();
72 fn add_slice(&mut self, slice_no: usize, data: &[u8]) -> DemuxerResult<()> {
73 validate!(self.hdr_size + self.frame_pos + data.len() <= self.frame.len());
74 self.write_slice_info(slice_no);
75 let dslice = &mut self.frame[self.hdr_size + self.frame_pos..][..data.len()];
76 dslice.copy_from_slice(data);
77 self.frame_pos += data.len();
80 fn write_slice_info(&mut self, slice_no: usize) {
81 let off = 1 + (slice_no - 1) * 8;
82 self.frame[off + 0] = 0;
83 self.frame[off + 1] = 0;
84 self.frame[off + 2] = 0;
85 self.frame[off + 3] = 1;
86 self.frame[off + 4] = (self.frame_pos >> 24) as u8;
87 self.frame[off + 5] = (self.frame_pos >> 16) as u8;
88 self.frame[off + 6] = (self.frame_pos >> 8) as u8;
89 self.frame[off + 7] = (self.frame_pos >> 0) as u8;
91 fn get_frame_data(&mut self) -> Vec<u8> {
92 let mut v: Vec<u8> = Vec::new();
93 mem::swap(&mut v, &mut self.frame);
99 #[derive(Clone,Copy,PartialEq)]
108 struct RMAudioStream {
109 deint: Deinterleaver,
110 iinfo: Option<InterleaveInfo>,
115 const RM_ILEAVE_INT0: u32 = mktag!(b"Int0");
116 const RM_ILEAVE_INT4: u32 = mktag!(b"Int4");
117 const RM_ILEAVE_GENR: u32 = mktag!(b"genr");
118 const RM_ILEAVE_SIPR: u32 = mktag!(b"sipr");
119 const RM_ILEAVE_VBRF: u32 = mktag!(b"vbrf");
120 const RM_ILEAVE_VBRS: u32 = mktag!(b"vbrs");
123 fn new(iinfo: Option<InterleaveInfo>) -> Self {
126 if let Some(info) = iinfo {
127 deint = match info.id {
128 RM_ILEAVE_INT0 => Deinterleaver::None,
129 RM_ILEAVE_INT4 => Deinterleaver::RA28_8,
130 RM_ILEAVE_GENR => Deinterleaver::Generic,
131 RM_ILEAVE_SIPR => Deinterleaver::Sipro,
132 RM_ILEAVE_VBRF => Deinterleaver::VBR,
133 RM_ILEAVE_VBRS => Deinterleaver::VBR,
134 _ => {println!("unknown deint {:X}", info.id); Deinterleaver::None },
137 Deinterleaver::None => { buf = Vec::new(); },
138 Deinterleaver::RA28_8 |
139 Deinterleaver::Generic |
140 Deinterleaver::Sipro => {
141 let bsize = (info.frame_size as usize) * (info.factor as usize);
142 buf = vec![0; bsize];
144 Deinterleaver::VBR => {
149 deint = Deinterleaver::None;
152 RMAudioStream { deint, iinfo, buf, sub_packet: 0 }
154 fn read_apackets(&mut self, queued_packets: &mut Vec<NAPacket>, src: &mut ByteReader, stream: NAStreamRef, ts: u32, keyframe: bool, payload_size: usize) -> DemuxerResult<NAPacket> {
155 let ts = stream.make_ts(Some(ts as u64), None, None);
161 Deinterleaver::None => { return src.read_packet(stream, ts, keyframe, payload_size); },
162 Deinterleaver::RA28_8 => {
163 let iinfo = self.iinfo.unwrap();
164 let factor = iinfo.factor as usize;
165 let halffact = factor >> 1;
166 let fsize = iinfo.frame_size as usize;
167 let bsize = iinfo.block_size as usize;
168 let ppos = self.sub_packet;
169 for sb in 0..halffact {
170 let dst = &mut self.buf[sb * 2 * fsize + ppos * bsize..][..bsize];
173 self.sub_packet += 1;
174 if self.sub_packet == factor {
176 return Ok(NAPacket::new(stream, ts, true, self.buf.clone()));
178 return Err(DemuxerError::TryAgain);
181 Deinterleaver::Generic => {
182 let iinfo = self.iinfo.unwrap();
183 let factor = iinfo.factor as usize;
184 let fsize = iinfo.frame_size as usize;
185 let bsize = iinfo.block_size as usize;
186 let factor2 = fsize / bsize;
187 let ppos = self.sub_packet;
189 for sb in 0..factor2 {
190 let sb_pos = factor * sb + ((factor + 1) >> 1) * (ppos & 1) + (ppos >> 1);
191 let dst = &mut self.buf[bsize * sb_pos..][..bsize];
195 Deinterleaver::Sipro => {
196 let iinfo = self.iinfo.unwrap();
197 let fsize = iinfo.frame_size as usize;
198 let ppos = self.sub_packet;
200 let dst = &mut self.buf[fsize * ppos..][..fsize];
203 Deinterleaver::VBR => {
204 validate!(payload_size >= 5);
205 let hdrsizesize = src.read_u16be()?;
206 let num_entries = (hdrsizesize / 16) as usize;
207 validate!(payload_size >= num_entries * 3 + 2);
208 let mut sizes: Vec<usize> = Vec::with_capacity(num_entries);
209 let mut tot_size = 0;
210 for _ in 0..num_entries {
211 let sz = src.read_u16be()? as usize;
215 validate!(tot_size + num_entries * 2 + 2 == payload_size);
216 let pkt_ts = stream.make_ts(None, None, None);
217 let mut first = true;
218 for size in sizes.iter() {
219 let cur_ts = if first { ts } else { pkt_ts };
221 let pkt = src.read_packet(stream.clone(), cur_ts, true, *size)?;
222 queued_packets.push(pkt);
224 queued_packets.reverse();
225 let pkt0 = queued_packets.pop().unwrap();
230 let iinfo = self.iinfo.unwrap();
231 let factor = iinfo.factor as usize;
232 let fsize = if iinfo.block_size != 0 { iinfo.block_size } else { iinfo.frame_size } as usize;
234 self.sub_packet += 1;
235 if self.sub_packet < factor {
236 return Err(DemuxerError::TryAgain);
241 if self.deint == Deinterleaver::Sipro {
242 sipro_restore(&mut self.buf, factor, iinfo.frame_size as usize);
245 let mut frames_iter = self.buf.chunks(fsize);
246 let pkt0 = frames_iter.next().unwrap();
248 let pkt_ts = stream.make_ts(None, None, None);
249 for pkts in frames_iter {
250 let pkt = NAPacket::new(stream.clone(), pkt_ts, true, pkts.to_vec());
251 queued_packets.push(pkt);
253 queued_packets.reverse();
254 Ok(NAPacket::new(stream, ts, true, pkt0.to_vec()))
258 fn sipro_restore(buf: &mut [u8], factor: usize, fsize: usize) {
259 let stride = factor * fsize * 2 / 96;
261 let mut sidx = (RM_SIPRO_SWAPS[i][0] as usize) * stride;
262 let mut didx = (RM_SIPRO_SWAPS[i][1] as usize) * stride;
264 let in0 = buf[sidx >> 1];
265 let in1 = buf[didx >> 1];
266 let nib0 = (in0 >> ((sidx & 1) * 4)) & 0xF;
267 let nib1 = (in1 >> ((didx & 1) * 4)) & 0xF;
269 buf[didx >> 1] = (nib0 << (4 * (didx & 1))) | (in1 & (0xF << (4 * (!didx & 1))));
270 buf[sidx >> 1] = (nib1 << (4 * (sidx & 1))) | (in0 & (0xF << (4 * (!sidx & 1))));
278 struct SubstreamInfo {
285 sub_info: Vec<SubstreamInfo>,
292 sub_info: Vec::new(),
296 fn add_stream(&mut self, stream_no: u32) {
297 let ssinfo = SubstreamInfo { id: stream_no, map: Vec::new(), str_ids: Vec::new() };
298 self.sub_info.push(ssinfo);
300 fn get_substream_no(&self) -> u32 {
303 fn find_idx(&self, stream_no: u32) -> Option<usize> {
304 self.sub_info.iter().position(|x| x.id == stream_no)
306 fn add_map_rule(&mut self, map_ss: u16) {
307 let idx = self.sub_info.len() - 1;
308 self.sub_info[idx].map.push(map_ss);
310 fn add_substream(&mut self) {
311 let idx = self.sub_info.len() - 1;
312 self.sub_info[idx].str_ids.push(self.sstr_id);
315 fn is_mlti_stream(&self, stream_no: u32) -> bool {
316 self.find_idx(stream_no).is_some()
318 fn find_substream(&self, stream_no: u32, grp: u16) -> Option<u32> {
319 if let Some(idx) = self.find_idx(stream_no) {
320 if (grp as usize) < self.sub_info[idx].map.len() {
321 let sub_id = self.sub_info[idx].map[grp as usize] as usize;
322 if sub_id < self.sub_info[idx].str_ids.len() {
323 return Some(self.sub_info[idx].str_ids[sub_id]);
332 Audio(RMAudioStream),
333 Video(RMVideoStream),
338 struct CommonStreamData {
339 streams: Vec<RMStreamType>,
341 mlti_mapper: MLTIMapper,
344 impl CommonStreamData {
349 mlti_mapper: MLTIMapper::new(),
352 fn get_stream_id(&self, str_no: u32, pkt_grp: u16) -> u32 {
353 if !self.mlti_mapper.is_mlti_stream(str_no) {
356 self.mlti_mapper.find_substream(str_no, pkt_grp).unwrap()
359 fn find_stream(&self, stream_id: u32) -> Option<usize> {
360 self.str_ids.iter().position(|x| *x == stream_id)
364 struct RealMediaDemuxer<'a> {
365 src: &'a mut ByteReader<'a>,
373 str_data: CommonStreamData,
375 data_chunks: Vec<(u64, u32, u16)>,
376 cur_data_chunk: usize,
378 queued_pkts: Vec<NAPacket>,
382 fn find_codec_name(registry: &[(&[u8;4], &'static str)], fcc: u32) -> &'static str {
383 for &(fourcc, name) in registry {
384 if mktag!(fourcc) == fcc { return name; }
389 fn read_14or30(src: &mut ByteReader) -> DemuxerResult<(bool, u32)> {
390 let tmp = src.read_u16be()?;
391 let flag = (tmp & 0x8000) != 0;
392 if (tmp & 0x4000) == 0x4000 {
393 Ok((flag, ((tmp & 0x3FFF) as u32)))
395 let val = ((tmp as u32) << 16) | (src.read_u16be()? as u32);
396 Ok((flag, val & 0x3FFFFFFF))
400 fn read_video_buf(src: &mut ByteReader, stream: NAStreamRef, ts: u32, keyframe: bool, frame_size: usize) -> DemuxerResult<NAPacket> {
401 let size = (frame_size as usize) + 9;
402 let mut vec: Vec<u8> = vec![0; size];
403 //v[0] = 0; // 1 slice
405 src.read_buf(&mut vec[9..])?;
407 let ts = stream.make_ts(Some(ts as u64), None, None);
408 Ok(NAPacket::new(stream, ts, keyframe, vec))
411 fn read_multiple_frame(src: &mut ByteReader, stream: NAStreamRef, keyframe: bool, skip_mtype: bool) -> DemuxerResult<NAPacket> {
413 let mtype = src.read_byte()?;
414 validate!(mtype == 0xC0);
416 let (_, frame_size) = read_14or30(src)?;
417 let (_, timestamp) = read_14or30(src)?;
418 let _seq_no = src.read_byte()?;
419 //println!(" multiple frame size {} ts {} seq {}", frame_size, timestamp, seq_no);
421 read_video_buf(src, stream, timestamp, keyframe, frame_size as usize)
424 struct RMDemuxCommon {}
427 fn parse_stream_info(str_data: &mut CommonStreamData, strmgr: &mut StreamManager, stream_no: u32, edata: &[u8], duration: u32) -> DemuxerResult<bool> {
428 let mut is_mlti = false;
429 let mut mr = MemoryReader::new_read(edata);
430 let mut src = ByteReader::new(&mut mr);
431 let tag = src.read_u32be()?;
432 let tag2 = src.peek_u32be()?;
433 //println!("tag1 {:X} tag2 {:X}", tag, tag2);
434 if tag == mktag!('.', 'r', 'a', 0xFD) {
435 Self::parse_audio_stream(strmgr, &mut str_data.streams, stream_no, &mut src, edata, duration)?;
436 } else if ((tag2 == mktag!('V', 'I', 'D', 'O')) || (tag2 == mktag!('I', 'M', 'A', 'G'))) && ((tag as usize) <= edata.len()) {
437 Self::parse_video_stream(strmgr, &mut str_data.streams, stream_no, &mut src, edata, tag2, duration)?;
438 } else if tag == mktag!(b"LSD:") {
439 let extradata = Some(edata.to_owned());
441 src.read_skip(4)?; //version
442 let channels = src.read_u16be()?;
443 let samp_size = src.read_u16be()?;
444 let sample_rate = src.read_u32be()?;
446 println!("LSD sr {}, {} ch", sample_rate, channels);
447 let soniton = NASoniton::new(samp_size as u8, SONITON_FLAG_SIGNED);
448 let ahdr = NAAudioInfo::new(sample_rate, channels as u8, soniton, 1);
449 let nainfo = NACodecInfo::new("ralf", NACodecTypeInfo::Audio(ahdr), extradata);
450 let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, 1000, u64::from(duration)));
451 if res.is_none() { return Err(MemoryError); }
452 let astr = RMAudioStream::new(None);
453 str_data.streams.push(RMStreamType::Audio(astr));
454 } else if tag == mktag!(b"MLTI") {
456 let num_rules = src.read_u16be()? as usize;
458 str_data.mlti_mapper.add_stream(stream_no);
459 for _ in 0..num_rules {
460 let substr = src.read_u16be()?;
461 max_sub = max_sub.max(substr);
462 str_data.mlti_mapper.add_map_rule(substr);
464 let num_substreams = src.read_u16be()? as usize;
465 validate!(num_substreams > (max_sub as usize));
466 for _ in 0..num_substreams {
467 let hdr_size = src.read_u32be()? as usize;
468 validate!(hdr_size > 8);
469 let pos = src.tell() as usize;
470 src.read_skip(hdr_size)?;
471 str_data.mlti_mapper.add_substream();
473 let hdrsrc = &edata[pos..][..hdr_size];
474 let mut mr = MemoryReader::new_read(hdrsrc);
475 let mut hsrc = ByteReader::new(&mut mr);
477 let tag = hsrc.read_u32be()?;
478 let tag2 = hsrc.peek_u32be()?;
479 let stream_no = str_data.mlti_mapper.get_substream_no();
480 //todo check that all substreams are of the same type");
481 if tag == mktag!('.', 'r', 'a', 0xFD) {
482 Self::parse_audio_stream(strmgr, &mut str_data.streams, stream_no, &mut hsrc, hdrsrc, duration)?;
483 } else if (tag2 == mktag!('V', 'I', 'D', 'O')) && ((tag as usize) <= hdr_size) {
484 Self::parse_video_stream(strmgr, &mut str_data.streams, stream_no, &mut hsrc, hdrsrc, tag2, duration)?;
486 println!("unknown MLTI substream {:08X} / {:08X}", tag, tag2);
487 return Err(DemuxerError::InvalidData);
489 str_data.str_ids.push(stream_no);
493 str_data.streams.push(RMStreamType::Logical);
497 fn parse_audio_stream(strmgr: &mut StreamManager, streams: &mut Vec<RMStreamType>, stream_no: u32, src: &mut ByteReader, edata_: &[u8], duration: u32) -> DemuxerResult<()> {
498 let ver = src.read_u16be()?;
499 let ainfo = match ver {
510 println!("unknown version {}", ver);
511 return Err(DemuxerError::InvalidData);
514 println!(" got ainfo {:?}", ainfo);
515 let cname = find_codec_name(RM_AUDIO_CODEC_REGISTER, ainfo.fcc);
516 let blk_size = if ainfo.fcc != mktag!(b"sipr") {
517 ainfo.granularity as usize
519 validate!(ainfo.flavor <= 3);
520 RM_SIPRO_BLOCK_SIZES[ainfo.flavor as usize]
522 let srate = ainfo.sample_rate;
523 let soniton = NASoniton::new(ainfo.sample_size as u8, SONITON_FLAG_SIGNED);
524 let ahdr = NAAudioInfo::new(srate, ainfo.channels as u8, soniton, blk_size);
525 let extradata = if ainfo.edata_size == 0 {
528 let eslice = &edata_[(src.tell() as usize)..];
529 Some(eslice.to_vec())
531 let duration = if duration == 0 { ainfo.get_duration(1000) } else { u64::from(duration) };
532 let nainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
533 let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, 1000, duration));
534 if res.is_none() { return Err(MemoryError); }
536 let astr = RMAudioStream::new(ainfo.ileave_info);
537 streams.push(RMStreamType::Audio(astr));
540 #[allow(unused_variables)]
541 fn parse_video_stream(strmgr: &mut StreamManager, streams: &mut Vec<RMStreamType>, stream_no: u32, src: &mut ByteReader, edata_: &[u8], tag2: u32, duration: u32) -> DemuxerResult<()> {
543 let fcc = src.read_u32be()?;
544 let width = src.read_u16be()? as usize;
545 let height = src.read_u16be()? as usize;
546 let bpp = src.read_u16be()?;
547 let pad_w = src.read_u16be()?;
548 let pad_h = src.read_u16be()?;
550 if tag2 == mktag!('V', 'I', 'D', 'O') {
551 _fps = src.read_u32be()?;
555 let extradata: Option<Vec<u8>>;
557 let eslice = &edata_[(src.tell() as usize)..];
558 extradata = Some(eslice.to_vec());
562 let cname = find_codec_name(RM_VIDEO_CODEC_REGISTER, fcc);
564 let vhdr = NAVideoInfo::new(width, height, false, RGB24_FORMAT);
565 let vinfo = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), extradata);
566 let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no as u32, vinfo, 1, 1000, u64::from(duration)));
567 if res.is_none() { return Err(DemuxerError::MemoryError); }
569 let vstr = RMVideoStream::new();
570 streams.push(RMStreamType::Video(vstr));
573 #[allow(unused_variables)]
574 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> {
576 RMStreamType::Video(ref mut vstr) => {
578 let pos = src.tell();
579 let b0 = src.read_byte()?;
581 0 => { // partial frame
582 let b1 = src.read_byte()?;
583 let hdr1 = ((b0 as u16) << 8) | (b1 as u16);
584 let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
585 let packet_num = hdr1 & 0x7F;
586 let (_, frame_size) = read_14or30(src)?;
587 let (_, off) = read_14or30(src)?;
588 let seq_no = src.read_byte()?;
589 //println!(" mode 0 pkt {}/{} off {}/{} seq {}", packet_num, num_pkts, off, frame_size, seq_no);
590 let hdr_skip = (src.tell() - pos) as usize;
592 let slice_size = (payload_size - hdr_skip) as usize;
593 slice_buf.resize(slice_size, 0);
594 src.read_buf(slice_buf.as_mut_slice())?;
596 vstr.start_slice(num_pkts, frame_size as usize, slice_buf.as_slice());
598 vstr.add_slice(packet_num as usize, slice_buf.as_slice())?;
600 if (packet_num as usize) < num_pkts {
601 return Err(DemuxerError::TryAgain);
603 //todo: check if full frame is received
604 let ts = stream.make_ts(Some(ts as u64), None, None);
605 let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
608 1 => { // whole frame
609 let seq_no = src.read_byte()?;
610 //println!(" mode 1 seq {}", seq_no);
611 read_video_buf(src, stream, ts, keyframe, payload_size - 2)
613 2 => { // last partial frame
614 let b1 = src.read_byte()?;
615 let hdr1 = ((b0 as u16) << 8) | (b1 as u16);
616 let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
617 let packet_num = hdr1 & 0x7F;
618 let (_, frame_size) = read_14or30(src)?;
619 let (_, tail_size) = read_14or30(src)?;
620 let seq_no = src.read_byte()?;
621 //println!(" mode 2 pkt {}/{} tail {}/{} seq {}", packet_num, num_pkts, tail_size, frame_size, seq_no);
622 slice_buf.resize(tail_size as usize, 0);
623 src.read_buf(slice_buf.as_mut_slice())?;
624 if packet_num == 1 && frame_size == tail_size {
625 vstr.start_slice(num_pkts, frame_size as usize, slice_buf.as_slice());
627 vstr.add_slice(packet_num as usize, slice_buf.as_slice())?;
630 while src.tell() < pos + (payload_size as u64) {
631 let res = read_multiple_frame(src, stream.clone(), false, false);
632 if res.is_err() { break; }
633 queued_pkts.push(res.unwrap());
635 queued_pkts.reverse();
636 let ts = stream.make_ts(Some(ts as u64), None, None);
637 let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
640 _ => { // multiple frames
641 //println!(" mode 3");
642 let res = read_multiple_frame(src, stream.clone(), keyframe, true);
643 if res.is_err() { return res; }
644 while src.tell() < pos + (payload_size as u64) {
645 let res = read_multiple_frame(src, stream.clone(), false, false);
646 if res.is_err() { break; }
647 queued_pkts.push(res.unwrap());
649 queued_pkts.reverse();
654 RMStreamType::Audio(ref mut astr) => {
655 astr.read_apackets(queued_pkts, src, stream, ts, keyframe, payload_size)
658 src.read_skip(payload_size)?;
659 Err(DemuxerError::InvalidData)
665 impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> {
666 fn open(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()> {
667 self.read_header(strmgr, seek_idx)?;
671 #[allow(unused_variables)]
672 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
673 if !self.queued_pkts.is_empty() {
674 let pkt = self.queued_pkts.pop().unwrap();
678 if (self.cur_packet >= self.num_packets) || (self.src.tell() >= self.data_end) {
679 self.cur_data_chunk += 1;
680 if self.cur_data_chunk < self.data_chunks.len() {
681 let (pos, _, _) = self.data_chunks[self.cur_data_chunk];
682 self.src.seek(SeekFrom::Start(pos))?;
683 let res = read_chunk(self.src);
684 if let Ok((id, size, ver)) = res {
685 self.data_pos = self.src.tell();
687 self.data_end = self.data_pos + (size as u64);
688 if self.parse_data_start().is_ok() {
693 return Err(DemuxerError::EOF);
696 let pkt_start = self.src.tell();
697 let ver = self.src.read_u16be()?;
699 let len = self.src.read_u16be()? as usize;
700 let str_no = self.src.read_u16be()? as u32;
701 let ts = self.src.read_u32be()?;
705 pkt_grp = self.src.read_byte()? as u16;
706 flags = self.src.read_byte()?;
708 //asm_rule = self.src.read_u16be()?;
709 //asm_flags = self.src.read_byte()?;
710 self.src.read_skip(2)?;
712 self.src.read_skip(1)?;
715 let hdr_size = self.src.tell() - pkt_start;
716 //println!("packet @{:X} size {} for {} ts {} grp {} flags {:X}", pkt_start, len, str_no, ts, pkt_grp, flags);
717 self.cur_packet += 1;
719 let payload_size = len - (hdr_size as usize);
721 let stream_id = self.str_data.get_stream_id(str_no as u32, pkt_grp);
722 let sr = self.str_data.find_stream(stream_id);
724 //println!("stream {} not found", str_no);
725 self.src.read_skip(payload_size)?;
726 return Err(DemuxerError::InvalidData);
728 let str_id = sr.unwrap();
730 let streamres = strmgr.get_stream_by_id(stream_id);
731 if streamres.is_none() {
732 self.src.read_skip(payload_size)?;
735 let stream = streamres.unwrap();
736 //println!(" stream {}", str_id);
737 if strmgr.is_ignored_id(stream_id) {
738 self.src.read_skip(payload_size)?;
741 //todo skip unwanted packet
742 let keyframe = (flags & KEYFRAME_FLAG) != 0;
744 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);
745 if let Err(DemuxerError::TryAgain) = ret {
753 #[allow(unused_variables)]
754 fn seek(&mut self, time: NATimePoint, seek_idx: &SeekIndex) -> DemuxerResult<()> {
755 self.queued_pkts.clear();
756 let ret = seek_idx.find_pos(time);
758 return Err(DemuxerError::SeekError);
760 let ret = ret.unwrap();
761 let seek_pos = ret.pos;
762 for (pos, size, ver) in self.data_chunks.iter() {
763 if seek_pos < *pos { continue; }
764 let end = *pos + (*size as u64);
767 self.data_pos = seek_pos;
768 self.data_ver = *ver;
770 self.src.seek(SeekFrom::Start(seek_pos))?;
774 Err(DemuxerError::SeekError)
777 fn get_duration(&self) -> u64 { 0 }
780 impl<'a> NAOptionHandler for RealMediaDemuxer<'a> {
781 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
782 fn set_options(&mut self, _options: &[NAOption]) { }
783 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
786 fn read_chunk(src: &mut ByteReader) -> DemuxerResult<(u32, u32, u16)> {
787 let id = src.read_u32be()?;
788 if id == 0 { return Ok((0, 0, 0)); }
789 let size = src.read_u32be()?;
791 let ver = src.read_u16be()?;
793 return Ok((id, 0x0FFFFFFF, ver));
795 validate!(size >= 10);
796 let ver = src.read_u16be()?;
801 #[derive(Clone,Copy,Debug)]
802 struct InterleaveInfo {
809 #[derive(Clone,Copy,Debug)]
811 struct RealAudioInfo {
819 bytes_per_minute: u32,
822 ileave_info: Option<InterleaveInfo>
826 fn get_duration(&self, base: u32) -> u64 {
827 if self.bytes_per_minute != 0 {
828 u64::from(self.total_bytes) * 60 * u64::from(base) / u64::from(self.bytes_per_minute)
835 fn skip_ra_metadata(src: &mut ByteReader) -> DemuxerResult<()> {
836 let title_len = src.read_byte()? as usize;
837 src.read_skip(title_len)?;
838 let author_len = src.read_byte()? as usize;
839 src.read_skip(author_len)?;
840 let copywrong_len = src.read_byte()? as usize;
841 src.read_skip(copywrong_len)?;
842 let comment_len = src.read_byte()? as usize;
843 src.read_skip(comment_len)?;
847 #[allow(unused_variables)]
848 fn parse_aformat3(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
849 let start = src.tell();
850 let header_len = src.read_u16be()?;
851 validate!(header_len >= 24);
852 let flavor = src.read_u16be()?;
853 let granularity = src.read_u32be()?;
854 let bytes_per_minute = src.read_u32be()?;
855 let total_bytes = src.read_u32be()?;
857 skip_ra_metadata(src)?;
859 let _can_copy = src.read_byte()?;
860 let fcc_len = src.read_byte()?;
861 validate!(fcc_len == 4);
862 let fcc = src.read_u32be()?;
864 let end = src.tell();
865 validate!(end - start <= (header_len as u64) + 2);
869 sample_rate: 8000, sample_size: 16, channels: 1, channel_mask: 0,
870 granularity, bytes_per_minute,
871 total_bytes, edata_size: 0,
876 #[allow(unused_variables)]
877 fn parse_aformat4(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
878 let start = src.tell();
879 src.read_skip(2)?; // zeroes
880 let id = src.read_u32be()?;
881 validate!(id == mktag!(b".ra4"));
882 let data_size = src.read_u32be()?;
883 let _ver4 = src.read_u16be()?; // should be 4
884 let header_size = src.read_u32be()?;
885 let flavor = src.read_u16be()?;
886 let granularity = src.read_u32be()?;
887 let total_bytes = src.read_u32be()?;
888 let bytes_per_minute = src.read_u32be()?;
889 let _bytes_per_minute2 = src.read_u32be()?;
890 let ileave_factor = src.read_u16be()?;
891 let ileave_block_size = src.read_u16be()?;
892 let _user_data = src.read_u16be()?;
893 let sample_rate = src.read_u32be()?;
894 let sample_size = src.read_u32be()?;
895 let channels = src.read_u16be()?;
896 let interleaver_id_len = src.read_byte()?;
897 validate!(interleaver_id_len == 4);
898 let interleaver_id = src.read_u32be()?;
899 let fcc_len = src.read_byte()?;
900 validate!(fcc_len == 4);
901 let fcc = src.read_u32be()?;
902 let is_interleaved = src.read_byte()?;
903 let _can_copy = src.read_byte()?;
904 let _stream_type = src.read_byte()?;
906 skip_ra_metadata(src)?;
908 let end = src.tell();
909 validate!(end - start <= (header_size as u64) + 10);
911 let ileave_info = if is_interleaved != 0 {
912 Some(InterleaveInfo {
913 id: interleaver_id, factor: ileave_factor, block_size: granularity as u16,
914 frame_size: ileave_block_size,
922 sample_rate, sample_size: sample_size as u16, channels, channel_mask: 0,
923 granularity, bytes_per_minute,
924 total_bytes: total_bytes & 0xFFFFFF, edata_size: 0,
929 #[allow(unused_variables)]
930 fn parse_aformat5(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
931 let start = src.tell();
932 src.read_skip(2)?; // zeroes
933 let id = src.read_u32be()?;
934 validate!((id == mktag!(b".ra5")) || (id == mktag!(b".ra4")));
935 let data_size = src.read_u32be()?;
936 let _ver5 = src.read_u16be()?; // should be 5
937 let header_size = src.read_u32be()?;
938 let flavor = src.read_u16be()?;
939 let granularity = src.read_u32be()?;
940 let total_bytes = src.read_u32be()?;
941 let bytes_per_minute = src.read_u32be()?;
942 let _bytes_per_minute2 = src.read_u32be()?;
943 let ileave_factor = src.read_u16be()?;
944 let frame_size = src.read_u16be()?;
945 let ileave_block_size = src.read_u16be()?;
946 let user_data = src.read_u32be()?;
947 let _sample_rate1 = src.read_u16be()?;
948 let sample_rate = src.read_u32be()?;
949 let sample_size = src.read_u32be()?;
950 let channels = src.read_u16be()?;
951 let interleaver_id = src.read_u32be()?;
952 let fcc = src.read_u32be()?;
953 let is_interleaved = src.read_byte()?;
954 let _can_copy = src.read_byte()?;
955 let _stream_type = src.read_byte()?;
956 let has_ileave_pattern = src.read_byte()?;
957 if has_ileave_pattern != 0 {
958 unimplemented!("ra5 interleave pattern");
960 let mut edata_size = src.read_u32be()?;
961 let end = src.tell();
962 if id == mktag!(b".ra5") {
963 validate!(end - start <= (header_size as u64) + 10);
964 // src.read_skip(((end - start) as usize) - (header_size as usize) - 10)?;
966 validate!(end - start <= (header_size as u64) + 15);
969 let ileave_info = if is_interleaved != 0 {
970 Some(InterleaveInfo {
971 id: interleaver_id, factor: ileave_factor, block_size: ileave_block_size, frame_size,
976 if (fcc == mktag!(b"raac")) || (fcc == mktag!(b"racp")) {
977 validate!(edata_size > 1);
984 sample_rate, sample_size: sample_size as u16, channels, channel_mask: 0,
985 granularity, bytes_per_minute,
986 total_bytes: total_bytes & 0xFFFFFF, edata_size,
991 const RMVB_HDR_SIZE: u32 = 18;
992 const RMVB_PROP_SIZE: u32 = 50;
993 const KEYFRAME_FLAG: u8 = 0x02;
995 impl<'a> RealMediaDemuxer<'a> {
996 fn new(io: &'a mut ByteReader<'a>) -> Self {
1005 str_data: CommonStreamData::new(),
1006 data_chunks: Vec::new(),
1008 queued_pkts: Vec::new(),
1009 slice_buf: Vec::new(),
1012 #[allow(unused_variables)]
1013 fn read_header(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()> {
1014 let (id, size, ver) = read_chunk(self.src)?;
1015 validate!((id == mktag!(b".RMF")) || (id == mktag!(b".RMP")));
1016 validate!(size >= RMVB_HDR_SIZE);
1017 let fver = self.src.read_u32be()?;
1018 validate!(fver <= 1);
1019 let num_hdr = self.src.read_u32be()? as usize;
1020 validate!(num_hdr >= 1);
1021 if size > RMVB_HDR_SIZE {
1022 self.src.read_skip((size - RMVB_HDR_SIZE) as usize)?;
1025 let (id, size, ver) = read_chunk(self.src)?;
1026 let prop_size = if ver == 0 { RMVB_PROP_SIZE } else { RMVB_PROP_SIZE + 4 };
1027 validate!(size >= prop_size);
1028 validate!((ver == 0) || (ver == 2));
1029 let maxbr = self.src.read_u32be()?;
1030 let avgbr = self.src.read_u32be()?;
1031 let maxps = self.src.read_u32be()?;
1032 let avgps = self.src.read_u32be()?;
1033 let num_pkt = self.src.read_u32be()? as usize;
1034 let duration = self.src.read_u32be()?;
1035 let preroll = self.src.read_u32be()?;
1036 let idx_off = self.src.read_size(ver)?;
1037 let data_off = self.src.read_u32be()?;
1038 let num_streams = self.src.read_u16be()? as usize;
1039 let flags = self.src.read_u16be()?;
1040 if size > prop_size {
1041 self.src.read_skip((size - prop_size) as usize)?;
1044 for _ in 0..num_hdr {
1045 if self.src.is_eof() {
1049 let res = self.parse_chunk(strmgr, seek_idx);
1051 Ok(last) => { if last { break; } },
1052 Err(DemuxerError::IOError) => { break; },
1054 if self.data_chunks.is_empty() { // data is not found, report error
1060 //println!("now @ {:X} / {}", self.src.tell(), self.data_pos);
1061 validate!(!self.data_chunks.is_empty());
1062 self.cur_data_chunk = 0;
1063 let (pos, size, ver) = self.data_chunks[self.cur_data_chunk];
1064 self.data_pos = pos;
1065 self.data_ver = ver;
1066 self.data_end = pos + (size as u64);
1067 self.src.seek(SeekFrom::Start(self.data_pos + 10))?;
1068 self.parse_data_start()?;
1071 fn parse_data_start(&mut self) -> DemuxerResult<()> {
1072 let num_packets = self.src.read_u32be()?;
1073 if self.data_ver == 2 {
1074 self.src.read_skip(12)?; // zeroes?
1076 let next_data_hdr = self.src.read_u32be()?;
1077 self.num_packets = if num_packets > 0 { num_packets } else { 0xFFFFFF };
1078 self.cur_packet = 0;
1079 self.next_data = next_data_hdr as u64;
1082 fn parse_chunk(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<bool> {
1083 let (id, size, ver) = read_chunk(self.src)?;
1084 let end_pos = self.src.tell() - 10 + (size as u64);
1086 validate!((ver == 0) || (ver == 2));
1087 if id == mktag!(b"CONT") { self.parse_content_desc()?; }
1088 else if id == mktag!(b"MDPR") { self.parse_mdpr(strmgr)?; }
1089 else if id == mktag!(b"DATA") {
1090 self.data_chunks.push((self.src.tell() - 10, size, ver));
1092 else if id == mktag!(b"INDX") {
1093 if !seek_idx.skip_index {
1094 self.parse_index(seek_idx, (size as usize) - 10, ver)?;
1097 else if id == 0 { return Ok(true); }
1098 else { println!("unknown chunk type {:08X}", id); }
1100 let cpos = self.src.tell();
1102 self.src.read_skip((end_pos - cpos) as usize)?;
1106 #[allow(unused_variables)]
1107 fn parse_content_desc(&mut self) -> DemuxerResult<()> {
1108 let title_len = self.src.read_u16be()? as usize;
1109 self.src.read_skip(title_len)?;
1110 let author_len = self.src.read_u16be()? as usize;
1111 self.src.read_skip(author_len)?;
1112 let copywrong_len = self.src.read_u16be()? as usize;
1113 self.src.read_skip(copywrong_len)?;
1114 let comment_len = self.src.read_u16be()? as usize;
1115 self.src.read_skip(comment_len)?;
1118 #[allow(unused_variables)]
1119 fn parse_mdpr(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
1120 let stream_no = self.src.read_u16be()? as u32;
1121 //todo check stream_no for duplicates
1122 let maxbr = self.src.read_u32be()?;
1123 let avgbr = self.src.read_u32be()?;
1124 let maxps = self.src.read_u32be()?;
1125 let avgps = self.src.read_u32be()?;
1126 let start = self.src.read_u32be()?;
1127 let preroll = self.src.read_u32be()?;
1128 let duration = self.src.read_u32be()?;
1129 let sname_size = self.src.read_byte()? as usize;
1130 let sname = read_string_size(self.src, sname_size)?;
1131 //println!("str #{} sname = {} pkts {}/{} start {} preroll {}", stream_no, sname, maxps, avgps, start, preroll);
1132 let mime_size = self.src.read_byte()? as usize;
1133 let mime = read_string_size(self.src, mime_size)?;
1134 //println!("mime = {}", mime);
1135 let edata_size = self.src.read_u32be()? as usize;
1136 let edata: Option<Vec<u8>> = if edata_size == 0 { None } else {
1137 let mut edvec: Vec<u8> = vec![0; edata_size];
1138 self.src.read_buf(&mut edvec)?;
1141 let mut is_mlti = false;
1143 if let Some(edata_) = edata {
1144 is_mlti = RMDemuxCommon::parse_stream_info(&mut self.str_data, strmgr, stream_no, &edata_, duration)?;
1147 self.str_data.streams.push(RMStreamType::Unknown);
1150 self.str_data.str_ids.push(stream_no);
1155 fn parse_index(&mut self, seek_idx: &mut SeekIndex, chunk_size: usize, ver: u16) -> DemuxerResult<()> {
1156 if ver != 0 && ver != 2 { return Ok(()); }
1157 let num_entries = self.src.read_u32be()? as usize;
1158 let str_id = self.src.read_u16be()? as u32;
1159 let _next_idx = self.src.read_size(ver)?;
1161 validate!(chunk_size == num_entries * 14 + 10);
1163 validate!(chunk_size == num_entries * 18 + 14);
1165 if num_entries == 0 { return Ok(()); }
1167 seek_idx.add_stream(str_id);
1168 let idx = seek_idx.get_stream_index(str_id).unwrap();
1169 for _ in 0..num_entries {
1170 let iver = self.src.read_u16be()?;
1171 validate!(iver == ver);
1172 let ts = self.src.read_u32be()? as u64;
1173 let pos = self.src.read_size(ver)?;
1174 let _pkt_no = self.src.read_u32be()?;
1175 idx.add_entry(SeekEntry { time: ts, pts: 0, pos });
1178 seek_idx.mode = SeekIndexMode::Present;
1183 fn read_string_size(src: &mut ByteReader, size: usize) -> DemuxerResult<String> {
1184 let mut vec: Vec<u8> = Vec::new();
1186 let c = src.read_byte()?;
1189 if let Ok(res) = String::from_utf8(vec) {
1196 struct RealAudioDemuxer<'a> {
1197 src: &'a mut ByteReader<'a>,
1198 stream: Option<RMAudioStream>,
1202 queued_pkts: Vec<NAPacket>,
1205 impl<'a> DemuxCore<'a> for RealAudioDemuxer<'a> {
1206 #[allow(unused_variables)]
1207 fn open(&mut self, strmgr: &mut StreamManager, _seek_idx: &mut SeekIndex) -> DemuxerResult<()> {
1208 let magic = self.src.read_u32be()?;
1209 validate!(magic == mktag!(b".ra\xFD"));
1210 let ver = self.src.read_u16be()?;
1211 let ainfo = match ver {
1213 parse_aformat3(self.src)?
1216 parse_aformat4(self.src)?
1219 parse_aformat5(self.src)?
1222 println!("unknown version {}", ver);
1223 return Err(DemuxerError::InvalidData);
1226 println!(" got ainfo {:?}", ainfo);
1227 let cname = find_codec_name(RM_AUDIO_CODEC_REGISTER, ainfo.fcc);
1228 let blk_size = if ainfo.fcc != mktag!(b"sipr") {
1229 ainfo.granularity as usize
1231 validate!(ainfo.flavor <= 3);
1232 RM_SIPRO_BLOCK_SIZES[ainfo.flavor as usize]
1234 let srate = ainfo.sample_rate;
1235 let soniton = NASoniton::new(ainfo.sample_size as u8, SONITON_FLAG_SIGNED);
1236 let ahdr = NAAudioInfo::new(srate, ainfo.channels as u8, soniton, blk_size);
1237 let extradata = if ainfo.edata_size == 0 {
1240 let mut dta: Vec<u8> = vec![0; ainfo.edata_size as usize];
1241 self.src.read_buf(dta.as_mut_slice())?;
1244 let nainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
1245 let res = strmgr.add_stream(NAStream::new(StreamType::Audio, 0, nainfo, 1, srate, ainfo.get_duration(ainfo.sample_rate)));
1246 if res.is_none() { return Err(MemoryError); }
1248 let astr = RMAudioStream::new(ainfo.ileave_info);
1249 self.data_start = self.src.tell();
1250 self.data_end = if ainfo.total_bytes > 0 { self.src.tell() + (ainfo.total_bytes as u64) } else { 0 };
1251 self.blk_size = blk_size;
1252 self.stream = Some(astr);
1257 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
1258 if !self.queued_pkts.is_empty() {
1259 let pkt = self.queued_pkts.pop().unwrap();
1262 if (self.data_end != 0) && (self.src.tell() >= self.data_end) {
1263 return Err(DemuxerError::EOF);
1265 let streamres = strmgr.get_stream_by_id(0);
1266 let stream = streamres.unwrap();
1267 if let Some(ref mut astr) = self.stream {
1269 let ret = astr.read_apackets(&mut self.queued_pkts, self.src, stream.clone(), 0, false, self.blk_size);
1270 if let Err(DemuxerError::TryAgain) = ret {
1276 Err(DemuxerError::NoSuchInput)
1279 #[allow(unused_variables)]
1280 fn seek(&mut self, time: NATimePoint, seek_idx: &SeekIndex) -> DemuxerResult<()> {
1284 fn get_duration(&self) -> u64 { 0 }
1287 impl<'a> NAOptionHandler for RealAudioDemuxer<'a> {
1288 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
1289 fn set_options(&mut self, _options: &[NAOption]) { }
1290 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
1293 impl<'a> RealAudioDemuxer<'a> {
1294 fn new(io: &'a mut ByteReader<'a>) -> Self {
1301 queued_pkts: Vec::new(),
1308 StreamProperties(usize),
1309 Packet { ts: u32, strm: u32, flags: u32, len: usize, checksum: u32 },
1310 IntValue(Vec<u8>, u32),
1311 BinaryData(Vec<u8>, Vec<u8>),
1312 StringData(Vec<u8>, Vec<u8>),
1319 fn read_string(src: &mut ByteReader) -> DemuxerResult<Vec<u8>> {
1320 let len = src.read_u32be()? as usize;
1321 let mut val = vec![0; len];
1322 src.read_buf(val.as_mut_slice())?;
1326 fn read(src: &mut ByteReader) -> DemuxerResult<Self> {
1327 let code = src.read_byte()?;
1330 let val = src.read_u32be()? as usize;
1331 Ok(IVRRecord::StreamProperties(val))
1334 let ts = src.read_u32be()?;
1335 let strm = src.read_u16be()? as u32;
1336 let flags = src.read_u32be()?;
1337 let len = src.read_u32be()? as usize;
1338 let chk = src.read_u32be()?;
1339 validate!((len > 0) && (len < (1 << 24)));
1340 Ok(IVRRecord::Packet { ts, strm, flags, len, checksum: chk })
1343 let name = Self::read_string(src)?;
1344 let len = src.read_u32be()?;
1345 validate!(len == 4);
1346 let val = src.read_u32be()?;
1347 Ok(IVRRecord::IntValue(name, val))
1350 let name = Self::read_string(src)?;
1351 let len = src.read_u32be()? as usize;
1352 let mut val = vec![0; len];
1353 src.read_buf(val.as_mut_slice())?;
1354 Ok(IVRRecord::BinaryData(name, val))
1357 let name = Self::read_string(src)?;
1358 let val = Self::read_string(src)?;
1359 Ok(IVRRecord::StringData(name, val))
1361 6 => Ok(IVRRecord::HeaderEnd),
1363 src.read_skip(8)?; // always zero?
1364 Ok(IVRRecord::DataEnd)
1367 src.read_skip(8)?; // always zero?
1368 Ok(IVRRecord::DataStart)
1370 _ => Ok(IVRRecord::Invalid(code)),
1373 fn is_data_start(&self) -> bool {
1374 matches!(*self, IVRRecord::DataStart)
1378 impl fmt::Display for IVRRecord {
1379 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1381 IVRRecord::Invalid(typ) => write!(f, "Invalid({:02X})", typ),
1382 IVRRecord::StreamProperties(num) =>
1383 write!(f, "({} stream properties)", num),
1384 IVRRecord::Packet { ts, strm, flags, len, checksum } =>
1385 write!(f, "paket({}, {}, {:X}, {}, {})", ts, strm, flags, len, checksum),
1386 IVRRecord::IntValue(ref name, val) =>
1387 write!(f, "({} = {})", String::from_utf8_lossy(name), val),
1388 IVRRecord::BinaryData(ref name, ref val) =>
1389 write!(f, "({} = {} bytes)", String::from_utf8_lossy(name), val.len()),
1390 IVRRecord::StringData(ref name, ref val) =>
1391 write!(f, "({} = {})", String::from_utf8_lossy(name), String::from_utf8_lossy(val)),
1392 IVRRecord::HeaderEnd => write!(f, "header end"),
1393 IVRRecord::DataEnd => write!(f, "data end"),
1394 IVRRecord::DataStart => write!(f, "data start"),
1399 struct RecordDemuxer {
1403 remap_ids: Vec<u32>,
1406 impl RecordDemuxer {
1407 fn new(pos: u64, start_str: u32) -> Self {
1412 remap_ids: Vec::new(),
1415 fn parse_header(&mut self, src: &mut ByteReader, strmgr: &mut StreamManager, str_data: &mut CommonStreamData) -> DemuxerResult<()> {
1416 src.seek(SeekFrom::Start(self.cur_pos))?;
1417 let magic = src.read_u32be()?;
1418 validate!(magic == mktag!(b".REC"));
1419 let _smth = src.read_byte()?;
1420 let num_entries = src.read_u32be()? as usize;
1421 for _ in 0..num_entries {
1422 let _rec = IVRRecord::read(src)?;
1423 //println!(" header rec {}", _rec);
1425 let mut has_seek_table = false;
1426 let mut cur_str_no = 0;
1428 let rec = IVRRecord::read(src)?;
1430 IVRRecord::HeaderEnd => { break; },
1431 IVRRecord::StreamProperties(num) => {
1432 let stream_no = cur_str_no + self.start_str;
1434 let mut parsed = false;
1435 let mut real_stream_no = 0;
1436 let mut duration = 0;
1438 let rec = IVRRecord::read(src)?;
1439 //println!(" strm property {}", rec);
1441 IVRRecord::IntValue(ref name, val) => {
1442 if name == b"StreamNumber\0" {
1443 real_stream_no = val;
1445 if name == b"Duration\0" {
1449 IVRRecord::BinaryData(ref name, ref val) => {
1450 if name == b"OpaqueData\0" {
1452 let is_mlti = RMDemuxCommon::parse_stream_info(str_data, strmgr, stream_no, val, duration)?;
1454 str_data.str_ids.push(stream_no);
1459 IVRRecord::StringData(ref name, ref val) => {
1460 if (name == b"SeekType\0") && (val != b"None\0") {
1461 has_seek_table = true;
1464 _ => { return Err(DemuxerError::InvalidData); }
1468 str_data.streams.push(RMStreamType::Unknown);
1469 str_data.str_ids.push(stream_no);
1471 self.remap_ids.push(real_stream_no);
1473 _ => {println!(" unexpected {}", rec); return Err(DemuxerError::InvalidData); }
1476 println!(" now @ {:X}", src.tell());
1477 let off0 = src.read_u32be()? as u64;
1478 let _off1 = src.read_u32be()?;
1479 let _off2 = src.read_u32be()?;
1480 validate!(off0 + self.start_pos == src.tell());
1481 println!(" has seek tab: {}", has_seek_table);
1484 let data_off = src.read_u32be()? as u64;
1485 println!(" new off {:X}", data_off);
1486 let pos = src.tell();
1487 validate!(data_off + self.start_pos > pos);
1488 src.read_skip((data_off + self.start_pos - pos) as usize)?;
1489 let rec = IVRRecord::read(src)?;
1490 validate!(rec.is_data_start());
1492 let ntype = src.peek_byte()?;
1493 validate!((ntype == 2) || (ntype == 7)); // packet or data end, no start
1496 self.cur_pos = src.tell();
1500 fn get_packet(&mut self, src: &mut ByteReader, str_data: &mut CommonStreamData, strmgr: &StreamManager, queued_pkts: &mut Vec<NAPacket>, slice_buf: &mut Vec<u8>) -> DemuxerResult<NAPacket> {
1501 src.seek(SeekFrom::Start(self.cur_pos))?;
1503 let rec = IVRRecord::read(src)?;
1505 IVRRecord::Packet { ts, strm, flags, len, .. } => {
1506 let payload_size = len;
1507 let sr = self.remap_ids.iter().position(|x| *x == strm);
1508 validate!(sr.is_some());
1509 let str_no = self.start_str + (sr.unwrap() as u32);
1510 let pkt_grp = ((flags >> 8) & 0xFF) as u16;
1511 let stream_id = str_data.get_stream_id(str_no as u32, pkt_grp);
1512 let sr = str_data.find_stream(stream_id);
1514 src.read_skip(payload_size)?;
1515 return Err(DemuxerError::InvalidData);
1517 let str_id = sr.unwrap();
1519 let streamres = strmgr.get_stream_by_id(stream_id);
1520 if streamres.is_none() {
1521 src.read_skip(payload_size)?;
1524 let stream = streamres.unwrap();
1525 if strmgr.is_ignored_id(stream_id) {
1526 src.read_skip(payload_size)?;
1529 let keyframe = false;
1530 let ret = RMDemuxCommon::parse_packet_payload(src, &mut str_data.streams[str_id], stream, slice_buf, queued_pkts, keyframe, ts, payload_size);
1531 if let Err(DemuxerError::TryAgain) = ret {
1534 self.cur_pos = src.tell();
1538 IVRRecord::DataEnd => return Err(DemuxerError::EOF),
1539 _ => return Err(DemuxerError::InvalidData),
1545 struct RealIVRDemuxer<'a> {
1546 src: &'a mut ByteReader<'a>,
1547 recs: Vec<RecordDemuxer>,
1549 queued_pkts: Vec<NAPacket>,
1551 str_data: CommonStreamData,
1554 impl<'a> DemuxCore<'a> for RealIVRDemuxer<'a> {
1555 #[allow(unused_variables)]
1556 fn open(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()> {
1557 let magic = self.src.peek_u32be()?;
1558 if magic == mktag!(b".REC") {
1559 let mut rec = RecordDemuxer::new(0, 0);
1560 rec.parse_header(self.src, strmgr, &mut self.str_data)?;
1561 self.recs.push(rec);
1562 } else if magic == mktag!(b".R1M") {
1563 println!("R1M kind");
1564 self.src.read_skip(4)?; // magic
1565 self.src.read_skip(3)?; // always 0, 1, 1 ?
1566 let _name = IVRRecord::read_string(self.src)?;
1567 self.src.read_skip(1)?; // always 0?
1568 let len1 = self.src.read_u32be()? as u64;
1569 let off1 = self.src.read_u64be()?;
1570 let cpos = self.src.tell();
1571 validate!(off1 == len1 + cpos - 8);
1572 self.src.read_skip((off1 - cpos) as usize)?;
1574 let typ = self.src.read_byte()?;
1575 println!(" at {:X} type {:02X}", self.src.tell(), typ);
1578 let len = self.src.read_u32be()?;
1579 self.src.read_skip(len as usize)?;
1582 let len = self.src.read_u32be()? as u64;
1583 let pos = self.src.tell();
1585 let num_streams = self.str_data.streams.len() as u32;
1586 let mut rec = RecordDemuxer::new(pos + 12, num_streams);
1587 rec.parse_header(self.src, strmgr, &mut self.str_data)?;
1588 self.recs.push(rec);
1590 self.src.seek(SeekFrom::Start(pos + len))?;
1593 let mut buf: [u8; 2] = [0; 2];
1594 self.src.peek_buf(&mut buf)?;
1595 if (buf[0] == b'J') && (buf[1] == b'M') { // RJMx markers at the end of file
1598 return Err(DemuxerError::InvalidData);
1601 _ => { return Err(DemuxerError::InvalidData); },
1605 return Err(DemuxerError::InvalidData);
1611 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
1612 if !self.queued_pkts.is_empty() {
1613 let pkt = self.queued_pkts.pop().unwrap();
1617 if self.cur_rec >= self.recs.len() { return Err(DemuxerError::EOF); }
1618 let res = self.recs[self.cur_rec].get_packet(self.src, &mut self.str_data, strmgr, &mut self.queued_pkts, &mut self.slice_buf);
1619 if let Err(DemuxerError::EOF) = res {
1627 #[allow(unused_variables)]
1628 fn seek(&mut self, time: NATimePoint, seek_idx: &SeekIndex) -> DemuxerResult<()> {
1632 fn get_duration(&self) -> u64 { 0 }
1635 impl<'a> NAOptionHandler for RealIVRDemuxer<'a> {
1636 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
1637 fn set_options(&mut self, _options: &[NAOption]) { }
1638 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
1641 impl<'a> RealIVRDemuxer<'a> {
1642 fn new(io: &'a mut ByteReader<'a>) -> Self {
1647 queued_pkts: Vec::new(),
1648 slice_buf: Vec::new(),
1649 str_data: CommonStreamData::new(),
1654 static RM_VIDEO_CODEC_REGISTER: &[(&[u8;4], &str)] = &[
1655 (b"RV10", "realvideo1"),
1656 (b"RV20", "realvideo2"),
1657 (b"RVTR", "realvideo2"),
1658 (b"RV30", "realvideo3"),
1659 (b"RV40", "realvideo4"),
1660 (b"RV60", "realvideo6"),
1661 (b"CLV1", "clearvideo_rm"),
1664 static RM_AUDIO_CODEC_REGISTER: &[(&[u8;4], &str)] = &[
1665 (b"lpcJ", "ra14.4"),
1666 (b"28_8", "ra28.8"),
1670 (b"atrc", "atrac3"),
1676 pub struct RealMediaDemuxerCreator { }
1678 impl DemuxerCreator for RealMediaDemuxerCreator {
1679 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
1680 Box::new(RealMediaDemuxer::new(br))
1682 fn get_name(&self) -> &'static str { "realmedia" }
1685 pub struct RealAudioDemuxerCreator { }
1687 impl DemuxerCreator for RealAudioDemuxerCreator {
1688 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
1689 Box::new(RealAudioDemuxer::new(br))
1691 fn get_name(&self) -> &'static str { "realaudio" }
1694 pub struct RealIVRDemuxerCreator { }
1696 impl DemuxerCreator for RealIVRDemuxerCreator {
1697 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
1698 Box::new(RealIVRDemuxer::new(br))
1700 fn get_name(&self) -> &'static str { "real_ivr" }
1709 fn test_rm_demux() {
1710 // sample from a private collection
1712 File::open("assets/RV/rv10_dnet_640x352_realvideo_encoder_4.0.rm").unwrap();
1713 // File::open("assets/RV/rv20_cook_640x352_realproducer_plus_8.51.rm").unwrap();
1714 // File::open("assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm").unwrap();
1715 // File::open("assets/RV/rv30_atrc_384x208_realproducer_plus_8.51.rm").unwrap();
1716 // File::open("assets/RV/rv30_chroma_drift.rm").unwrap();
1717 // File::open("assets/RV/rv30_weighted_mc.rm").unwrap();
1718 // File::open("assets/RV/rv40_weighted_mc.rmvb").unwrap();
1719 // File::open("assets/RV/rv40_weighted_mc_2.rmvb").unwrap();
1720 // File::open("assets/RV/clv1_sipr_384x208_realvideo_encoder_4.0.rm").unwrap();
1721 // File::open("assets/RV/luckynight.rmvb").unwrap();
1722 // File::open("assets/RV/rv40_ralf.rmvb").unwrap();
1723 let mut fr = FileReader::new_read(&mut file);
1724 let mut br = ByteReader::new(&mut fr);
1725 let mut dmx = RealMediaDemuxer::new(&mut br);
1726 let mut sm = StreamManager::new();
1727 let mut si = SeekIndex::new();
1728 dmx.open(&mut sm, &mut si).unwrap();
1731 let pktres = dmx.get_frame(&mut sm);
1732 if let Err(e) = pktres {
1733 if e == DemuxerError::EOF { break; }
1736 let pkt = pktres.unwrap();
1737 println!("Got {}", pkt);
1739 //panic!("the end");
1742 fn test_ra_demux() {
1743 // sample: https://samples.mplayerhq.hu/real//RA/ra_with_comment_field/diemusik.ra
1745 // File::open("assets/RV/welcome288.ra").unwrap();
1746 File::open("assets/RV/diemusik.ra").unwrap();
1747 let mut fr = FileReader::new_read(&mut file);
1748 let mut br = ByteReader::new(&mut fr);
1749 let mut dmx = RealAudioDemuxer::new(&mut br);
1750 let mut sm = StreamManager::new();
1751 let mut si = SeekIndex::new();
1752 dmx.open(&mut sm, &mut si).unwrap();
1755 let pktres = dmx.get_frame(&mut sm);
1756 if let Err(e) = pktres {
1757 if e == DemuxerError::EOF { break; }
1760 let pkt = pktres.unwrap();
1761 println!("Got {}", pkt);
1765 fn test_ivr_demux() {
1766 // sample: https://samples.mplayerhq.hu/real/ivr/Opener_rm_hi.ivr
1768 File::open("assets/RV/Opener_rm_hi.ivr").unwrap();
1769 // File::open("assets/RV/SherwinWilliamsCommercial.ivr").unwrap();
1770 let mut fr = FileReader::new_read(&mut file);
1771 let mut br = ByteReader::new(&mut fr);
1772 let mut dmx = RealIVRDemuxer::new(&mut br);
1773 let mut sm = StreamManager::new();
1774 let mut si = SeekIndex::new();
1775 dmx.open(&mut sm, &mut si).unwrap();
1778 let pktres = dmx.get_frame(&mut sm);
1779 if let Err(e) = pktres {
1780 if e == DemuxerError::EOF { break; }
1783 let pkt = pktres.unwrap();
1784 println!("Got {}", pkt);