2 use super::DemuxerError::*;
11 ($a:expr, $b:expr, $c:expr, $d:expr) => ({
12 (($a as u32) << 24) | (($b as u32) << 16) | (($c as u32) << 8) | ($d as u32)
15 (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
19 const RM_SIPRO_BLOCK_SIZES: [usize; 4] = [ 29, 19, 37, 20 ];
20 const RM_SIPRO_SWAPS: [[u8; 2]; 38] = [
21 [ 0, 63 ], [ 1, 22 ], [ 2, 44 ], [ 3, 90 ],
22 [ 5, 81 ], [ 7, 31 ], [ 8, 86 ], [ 9, 58 ],
23 [ 10, 36 ], [ 12, 68 ], [ 13, 39 ], [ 14, 73 ],
24 [ 15, 53 ], [ 16, 69 ], [ 17, 57 ], [ 19, 88 ],
25 [ 20, 34 ], [ 21, 71 ], [ 24, 46 ], [ 25, 94 ],
26 [ 26, 54 ], [ 28, 75 ], [ 29, 50 ], [ 32, 70 ],
27 [ 33, 92 ], [ 35, 74 ], [ 38, 85 ], [ 40, 56 ],
28 [ 42, 87 ], [ 43, 65 ], [ 45, 59 ], [ 48, 79 ],
29 [ 49, 93 ], [ 51, 89 ], [ 55, 95 ], [ 61, 76 ],
30 [ 67, 83 ], [ 77, 80 ]
33 struct RMVideoStream {
50 self.frame.truncate(0);
54 fn start_slice(&mut self, num_slices: usize, frame_size: usize, data: &[u8]) {
55 self.hdr_size = num_slices * 8 + 1;
56 self.frame.resize(frame_size + self.hdr_size, 0);
57 self.frame[0] = (num_slices - 1) as u8;
59 self.add_slice(1, data);
61 fn add_slice(&mut self, slice_no: usize, data: &[u8]) {
62 self.write_slice_info(slice_no);
63 let dslice = &mut self.frame[self.hdr_size + self.frame_pos..][..data.len()];
64 dslice.copy_from_slice(data);
65 self.frame_pos += data.len();
67 fn write_slice_info(&mut self, slice_no: usize) {
68 let off = 1 + (slice_no - 1) * 8;
69 self.frame[off + 0] = 0;
70 self.frame[off + 1] = 0;
71 self.frame[off + 2] = 0;
72 self.frame[off + 3] = 1;
73 self.frame[off + 4] = (self.frame_pos >> 24) as u8;
74 self.frame[off + 5] = (self.frame_pos >> 16) as u8;
75 self.frame[off + 6] = (self.frame_pos >> 8) as u8;
76 self.frame[off + 7] = (self.frame_pos >> 0) as u8;
78 fn get_frame_data(&mut self) -> Vec<u8> {
79 let mut v: Vec<u8> = Vec::new();
80 mem::swap(&mut v, &mut self.frame);
87 #[derive(Clone,Copy,PartialEq)]
97 struct RMAudioStream {
99 iinfo: Option<InterleaveInfo>,
104 const RM_ILEAVE_INT0: u32 = mktag!(b"Int0");
105 const RM_ILEAVE_INT4: u32 = mktag!(b"Int4");
106 const RM_ILEAVE_GENR: u32 = mktag!(b"genr");
107 const RM_ILEAVE_SIPR: u32 = mktag!(b"sipr");
108 const RM_ILEAVE_VBRF: u32 = mktag!(b"vbrf");
109 const RM_ILEAVE_VBRS: u32 = mktag!(b"vbrs");
112 fn new(iinfo: Option<InterleaveInfo>) -> Self {
114 let mut buf: Vec<u8>;
115 if let Some(info) = iinfo {
116 deint = match info.id {
117 RM_ILEAVE_INT0 => Deinterleaver::None,
118 RM_ILEAVE_INT4 => Deinterleaver::RA28_8,
119 RM_ILEAVE_GENR => Deinterleaver::Generic,
120 RM_ILEAVE_SIPR => Deinterleaver::Sipro,
121 RM_ILEAVE_VBRF => Deinterleaver::VBR,
122 RM_ILEAVE_VBRS => Deinterleaver::VBR,
123 _ => {println!("unknown deint {:X}", info.id); Deinterleaver::None },
126 Deinterleaver::None => { buf = Vec::new(); },
127 Deinterleaver::RA28_8 |
128 Deinterleaver::Generic |
129 Deinterleaver::Sipro => {
130 let bsize = (info.frame_size as usize) * (info.factor as usize);
131 buf = Vec::with_capacity(bsize);
132 buf.resize(bsize, 0u8);
134 Deinterleaver::VBR => {
139 deint = Deinterleaver::None;
142 RMAudioStream { deint: deint, iinfo: iinfo, buf: buf, sub_packet: 0 }
144 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> {
145 let (tb_num, tb_den) = stream.get_timebase();
146 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
152 Deinterleaver::None => { return src.read_packet(stream, ts, keyframe, payload_size); },
153 Deinterleaver::RA28_8 => {
154 let iinfo = self.iinfo.unwrap();
155 let factor = iinfo.factor as usize;
156 let halffact = factor >> 1;
157 let fsize = iinfo.frame_size as usize;
158 let bsize = iinfo.block_size as usize;
159 let ppos = self.sub_packet;
160 for sb in 0..halffact {
161 let mut dst = &mut self.buf[sb * 2 * fsize + ppos * bsize..][..bsize];
162 src.read_buf(&mut dst)?;
164 self.sub_packet += 1;
165 if self.sub_packet == factor {
167 return Ok(NAPacket::new(stream, ts, true, self.buf.clone()));
169 return Err(DemuxerError::TryAgain);
172 Deinterleaver::Generic => {
173 let iinfo = self.iinfo.unwrap();
174 let factor = iinfo.factor as usize;
175 let fsize = iinfo.frame_size as usize;
176 let bsize = iinfo.block_size as usize;
177 let factor2 = fsize / bsize;
178 let ppos = self.sub_packet;
180 for sb in 0..factor2 {
181 let sb_pos = factor * sb + ((factor + 1) >> 1) * (ppos & 1) + (ppos >> 1);
182 let mut dst = &mut self.buf[bsize * sb_pos..][..bsize];
183 src.read_buf(&mut dst)?;
186 Deinterleaver::Sipro => {
187 let iinfo = self.iinfo.unwrap();
188 let fsize = iinfo.frame_size as usize;
189 let ppos = self.sub_packet;
191 let mut dst = &mut self.buf[fsize * ppos..][..fsize];
192 src.read_buf(&mut dst)?;
194 Deinterleaver::VBR => {
195 validate!(payload_size >= 5);
196 let hdrsizesize = src.read_u16be()?;
197 let num_entries = (hdrsizesize / 16) as usize;
198 validate!(payload_size >= num_entries * 3 + 2);
199 let mut sizes: Vec<usize> = Vec::with_capacity(num_entries);
200 let mut tot_size = 0;
201 for _ in 0..num_entries {
202 let sz = src.read_u16be()? as usize;
206 validate!(tot_size + num_entries * 2 + 2 == payload_size);
207 let pkt_ts = NATimeInfo::new(None, None, None, tb_num, tb_den);
208 let mut first = true;
209 for size in sizes.iter() {
210 let cur_ts = if first { ts } else { pkt_ts };
212 let pkt = src.read_packet(stream.clone(), cur_ts, true, *size)?;
213 queued_packets.push(pkt);
215 queued_packets.reverse();
216 let pkt0 = queued_packets.pop().unwrap();
221 let iinfo = self.iinfo.unwrap();
222 let factor = iinfo.factor as usize;
223 let fsize = if iinfo.block_size != 0 { iinfo.block_size } else { iinfo.frame_size } as usize;
225 self.sub_packet += 1;
226 if self.sub_packet < factor {
227 return Err(DemuxerError::TryAgain);
232 if self.deint == Deinterleaver::Sipro {
233 sipro_restore(&mut self.buf, factor, fsize);
236 let mut frames_iter = self.buf.chunks(fsize);
237 let pkt0 = frames_iter.next().unwrap();
239 let pkt_ts = NATimeInfo::new(None, None, None, tb_num, tb_den);
240 for pkts in frames_iter {
241 let pkt = NAPacket::new(stream.clone(), pkt_ts, true, pkts.to_vec());
242 queued_packets.push(pkt);
244 queued_packets.reverse();
245 Ok(NAPacket::new(stream, ts, true, pkt0.to_vec()))
249 fn sipro_restore(buf: &mut [u8], factor: usize, fsize: usize) {
250 let stride = factor * fsize * 2 / 96;
252 let mut sidx = (RM_SIPRO_SWAPS[i][0] as usize) * stride;
253 let mut didx = (RM_SIPRO_SWAPS[i][1] as usize) * stride;
255 let in0 = buf[sidx >> 1];
256 let in1 = buf[didx >> 1];
257 let nib0 = (in0 >> ((sidx & 1) * 4)) & 0xF;
258 let nib1 = (in1 >> ((didx & 1) * 4)) & 0xF;
260 buf[didx >> 1] = (nib0 << (4 * (didx & 1))) | (in1 & (0xF << (4 * (!didx & 1))));
261 buf[sidx >> 1] = (nib1 << (4 * (sidx & 1))) | (in0 & (0xF << (4 * (!sidx & 1))));
269 struct SubstreamInfo {
276 sub_info: Vec<SubstreamInfo>,
283 sub_info: Vec::new(),
287 fn add_stream(&mut self, stream_no: u32) {
288 let ssinfo = SubstreamInfo { id: stream_no, map: Vec::new(), str_ids: Vec::new() };
289 self.sub_info.push(ssinfo);
291 fn get_substream_no(&self) -> u32 {
294 fn find_idx(&self, stream_no: u32) -> Option<usize> {
295 self.sub_info.iter().position(|x| x.id == stream_no)
297 fn add_map_rule(&mut self, map_ss: u16) {
298 let idx = self.sub_info.len() - 1;
299 self.sub_info[idx].map.push(map_ss);
301 fn add_substream(&mut self) {
302 let idx = self.sub_info.len() - 1;
303 self.sub_info[idx].str_ids.push(self.sstr_id);
306 fn is_mlti_stream(&self, stream_no: u32) -> bool {
307 self.find_idx(stream_no).is_some()
309 fn find_substream(&self, stream_no: u32, grp: u16) -> Option<u32> {
310 if let Some(idx) = self.find_idx(stream_no) {
311 if (grp as usize) < self.sub_info[idx].map.len() {
312 let sub_id = self.sub_info[idx].map[grp as usize] as usize;
313 if sub_id < self.sub_info[idx].str_ids.len() {
314 return Some(self.sub_info[idx].str_ids[sub_id]);
323 Audio(RMAudioStream),
324 Video(RMVideoStream),
329 struct CommonStreamData {
330 streams: Vec<RMStreamType>,
332 mlti_mapper: MLTIMapper,
335 impl CommonStreamData {
340 mlti_mapper: MLTIMapper::new(),
343 fn get_stream_id(&self, str_no: u32, pkt_grp: u16) -> u32 {
344 if !self.mlti_mapper.is_mlti_stream(str_no) {
347 self.mlti_mapper.find_substream(str_no, pkt_grp).unwrap()
350 fn find_stream(&self, stream_id: u32) -> Option<usize> {
351 self.str_ids.iter().position(|x| *x == stream_id)
355 struct RealMediaDemuxer<'a> {
356 src: &'a mut ByteReader<'a>,
363 str_data: CommonStreamData,
365 queued_pkts: Vec<NAPacket>,
369 fn find_codec_name(registry: &[(&[u8;4], &'static str)], fcc: u32) -> &'static str {
370 for &(fourcc, name) in registry {
371 if mktag!(fourcc) == fcc { return name; }
376 fn read_14or30(src: &mut ByteReader) -> DemuxerResult<(bool, u32)> {
377 let tmp = src.read_u16be()?;
378 let flag = (tmp & 0x8000) != 0;
379 if (tmp & 0x4000) == 0x4000 {
380 Ok((flag, ((tmp & 0x3FFF) as u32)))
382 let val = ((tmp as u32) << 16) | (src.read_u16be()? as u32);
383 Ok((flag, val & 0x3FFFFFFF))
387 fn read_video_buf(src: &mut ByteReader, stream: Rc<NAStream>, ts: u32, keyframe: bool, frame_size: usize) -> DemuxerResult<NAPacket> {
388 let size = (frame_size as usize) + 9;
389 let mut vec: Vec<u8> = Vec::with_capacity(size);
391 //v[0] = 0; // 1 slice
393 src.read_buf(&mut vec[9..])?;
395 let (tb_num, tb_den) = stream.get_timebase();
396 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
397 Ok(NAPacket::new(stream, ts, keyframe, vec))
400 fn read_multiple_frame(src: &mut ByteReader, stream: Rc<NAStream>, keyframe: bool, skip_mtype: bool) -> DemuxerResult<NAPacket> {
402 let mtype = src.read_byte()?;
403 validate!(mtype == 0xC0);
405 let (_, frame_size) = read_14or30(src)?;
406 let (_, timestamp) = read_14or30(src)?;
407 let _seq_no = src.read_byte()?;
408 //println!(" multiple frame size {} ts {} seq {}", frame_size, timestamp, seq_no);
410 read_video_buf(src, stream, timestamp, keyframe, frame_size as usize)
413 struct RMDemuxCommon {}
416 fn parse_stream_info(str_data: &mut CommonStreamData, strmgr: &mut StreamManager, stream_no: u32, edata: &Vec<u8>) -> DemuxerResult<bool> {
417 let mut is_mlti = false;
418 let mut mr = MemoryReader::new_read(edata.as_slice());
419 let mut src = ByteReader::new(&mut mr);
420 let tag = src.read_u32be()?;
421 let tag2 = src.peek_u32be()?;
422 //println!("tag1 {:X} tag2 {:X}", tag, tag2);
423 if tag == mktag!('.', 'r', 'a', 0xFD) {
424 Self::parse_audio_stream(strmgr, &mut str_data.streams, stream_no, &mut src, edata.as_slice())?;
425 } else if ((tag2 == mktag!('V', 'I', 'D', 'O')) || (tag2 == mktag!('I', 'M', 'A', 'G'))) && ((tag as usize) <= edata.len()) {
426 Self::parse_video_stream(strmgr, &mut str_data.streams, stream_no, &mut src, edata.as_slice(), tag2)?;
427 } else if tag == mktag!(b"LSD:") {
428 let extradata = Some(edata.clone());
430 src.read_skip(4)?; //version
431 let channels = src.read_u16be()?;
432 let samp_size = src.read_u16be()?;
433 let sample_rate = src.read_u32be()?;
435 println!("LSD sr {}, {} ch", sample_rate, channels);
436 let soniton = NASoniton::new(samp_size as u8, SONITON_FLAG_SIGNED);
437 let ahdr = NAAudioInfo::new(sample_rate, channels as u8, soniton, 1);
438 let nainfo = NACodecInfo::new("ralf", NACodecTypeInfo::Audio(ahdr), extradata);
439 let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, sample_rate));
440 if res.is_none() { return Err(MemoryError); }
441 let astr = RMAudioStream::new(None);
442 str_data.streams.push(RMStreamType::Audio(astr));
443 } else if tag == mktag!(b"MLTI") {
445 let num_rules = src.read_u16be()? as usize;
447 str_data.mlti_mapper.add_stream(stream_no);
448 for _ in 0..num_rules {
449 let substr = src.read_u16be()?;
450 max_sub = max_sub.max(substr);
451 str_data.mlti_mapper.add_map_rule(substr);
453 let num_substreams = src.read_u16be()? as usize;
454 validate!(num_substreams > (max_sub as usize));
455 for _ in 0..num_substreams {
456 let hdr_size = src.read_u32be()? as usize;
457 validate!(hdr_size > 8);
458 let pos = src.tell() as usize;
459 src.read_skip(hdr_size)?;
460 str_data.mlti_mapper.add_substream();
462 let hdrsrc = &edata[pos..][..hdr_size];
463 let mut mr = MemoryReader::new_read(hdrsrc);
464 let mut hsrc = ByteReader::new(&mut mr);
466 let tag = hsrc.read_u32be()?;
467 let tag2 = hsrc.peek_u32be()?;
468 let stream_no = str_data.mlti_mapper.get_substream_no();
469 //todo check that all substreams are of the same type");
470 if tag == mktag!('.', 'r', 'a', 0xFD) {
471 Self::parse_audio_stream(strmgr, &mut str_data.streams, stream_no, &mut hsrc, hdrsrc)?;
472 } else if (tag2 == mktag!('V', 'I', 'D', 'O')) && ((tag as usize) <= hdr_size) {
473 Self::parse_video_stream(strmgr, &mut str_data.streams, stream_no, &mut hsrc, hdrsrc, tag2)?;
475 println!("unknown MLTI substream {:08X} / {:08X}", tag, tag2);
476 return Err(DemuxerError::InvalidData);
478 str_data.str_ids.push(stream_no);
482 str_data.streams.push(RMStreamType::Logical);
486 fn parse_audio_stream(strmgr: &mut StreamManager, streams: &mut Vec<RMStreamType>, stream_no: u32, src: &mut ByteReader, edata_: &[u8]) -> DemuxerResult<()> {
487 let ver = src.read_u16be()?;
488 let ainfo = match ver {
499 println!("unknown version {}", ver);
500 return Err(DemuxerError::InvalidData);
503 println!(" got ainfo {:?}", ainfo);
504 let cname = find_codec_name(RM_AUDIO_CODEC_REGISTER, ainfo.fcc);
505 let blk_size = if ainfo.fcc != mktag!(b"sipr") {
506 ainfo.granularity as usize
508 validate!(ainfo.flavor <= 3);
509 RM_SIPRO_BLOCK_SIZES[ainfo.flavor as usize]
511 let srate = ainfo.sample_rate;
512 let soniton = NASoniton::new(ainfo.sample_size as u8, SONITON_FLAG_SIGNED);
513 let ahdr = NAAudioInfo::new(srate, ainfo.channels as u8, soniton, blk_size);
514 let extradata = if ainfo.edata_size == 0 {
517 let eslice = &edata_[(src.tell() as usize)..];
518 Some(eslice.to_vec())
520 let nainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
521 let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, srate));
522 if res.is_none() { return Err(MemoryError); }
524 let astr = RMAudioStream::new(ainfo.ileave_info);
525 streams.push(RMStreamType::Audio(astr));
528 #[allow(unused_variables)]
529 fn parse_video_stream(strmgr: &mut StreamManager, streams: &mut Vec<RMStreamType>, stream_no: u32, src: &mut ByteReader, edata_: &[u8], tag2: u32) -> DemuxerResult<()> {
531 let fcc = src.read_u32be()?;
532 let width = src.read_u16be()? as usize;
533 let height = src.read_u16be()? as usize;
534 let bpp = src.read_u16be()?;
535 let pad_w = src.read_u16be()?;
536 let pad_h = src.read_u16be()?;
538 if tag2 == mktag!('V', 'I', 'D', 'O') {
539 fps = src.read_u32be()?;
543 let extradata: Option<Vec<u8>>;
545 let eslice = &edata_[(src.tell() as usize)..];
546 extradata = Some(eslice.to_vec());
550 let cname = find_codec_name(RM_VIDEO_CODEC_REGISTER, fcc);
552 let vhdr = NAVideoInfo::new(width, height, false, RGB24_FORMAT);
553 let vinfo = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), extradata);
554 let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no as u32, vinfo, 0x10000, fps));
555 if res.is_none() { return Err(DemuxerError::MemoryError); }
557 let vstr = RMVideoStream::new();
558 streams.push(RMStreamType::Video(vstr));
561 #[allow(unused_variables)]
562 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> {
564 RMStreamType::Video(ref mut vstr) => {
566 let pos = src.tell();
567 let b0 = src.read_byte()?;
569 0 => { // partial frame
570 let b1 = src.read_byte()?;
571 let hdr1 = ((b0 as u16) << 8) | (b1 as u16);
572 let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
573 let packet_num = hdr1 & 0x7F;
574 let (_, frame_size) = read_14or30(src)?;
575 let (_, off) = read_14or30(src)?;
576 let seq_no = src.read_byte()?;
577 //println!(" mode 0 pkt {}/{} off {}/{} seq {}", packet_num, num_pkts, off, frame_size, seq_no);
578 let hdr_skip = (src.tell() - pos) as usize;
580 let slice_size = (payload_size - hdr_skip) as usize;
581 slice_buf.resize(slice_size, 0);
582 src.read_buf(slice_buf.as_mut_slice())?;
584 vstr.start_slice(num_pkts, frame_size as usize, slice_buf.as_slice());
586 vstr.add_slice(packet_num as usize, slice_buf.as_slice());
588 if (packet_num as usize) < num_pkts {
589 return Err(DemuxerError::TryAgain);
591 //todo: check if full frame is received
592 let (tb_num, tb_den) = stream.get_timebase();
593 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
594 let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
597 1 => { // whole frame
598 let seq_no = src.read_byte()?;
599 //println!(" mode 1 seq {}", seq_no);
600 read_video_buf(src, stream, ts, keyframe, payload_size - 2)
602 2 => { // last partial frame
603 let b1 = src.read_byte()?;
604 let hdr1 = ((b0 as u16) << 8) | (b1 as u16);
605 let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
606 let packet_num = hdr1 & 0x7F;
607 let (_, frame_size) = read_14or30(src)?;
608 let (_, tail_size) = read_14or30(src)?;
609 let seq_no = src.read_byte()?;
610 //println!(" mode 2 pkt {}/{} tail {}/{} seq {}", packet_num, num_pkts, tail_size, frame_size, seq_no);
611 slice_buf.resize(tail_size as usize, 0);
612 src.read_buf(slice_buf.as_mut_slice())?;
613 if packet_num == 1 && frame_size == tail_size {
614 vstr.start_slice(num_pkts, frame_size as usize, slice_buf.as_slice());
616 vstr.add_slice(packet_num as usize, slice_buf.as_slice());
619 while src.tell() < pos + (payload_size as u64) {
620 let res = read_multiple_frame(src, stream.clone(), false, false);
621 if res.is_err() { break; }
622 queued_pkts.push(res.unwrap());
624 queued_pkts.reverse();
625 let (tb_num, tb_den) = stream.get_timebase();
626 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
627 let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
630 _ => { // multiple frames
631 //println!(" mode 3");
632 let res = read_multiple_frame(src, stream.clone(), keyframe, true);
633 if res.is_err() { return res; }
634 while src.tell() < pos + (payload_size as u64) {
635 let res = read_multiple_frame(src, stream.clone(), false, false);
636 if res.is_err() { break; }
637 queued_pkts.push(res.unwrap());
639 queued_pkts.reverse();
644 RMStreamType::Audio(ref mut astr) => {
645 astr.read_apackets(queued_pkts, src, stream, ts, keyframe, payload_size)
648 src.read_skip(payload_size)?;
649 Err(DemuxerError::InvalidData)
655 impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> {
656 #[allow(unused_variables)]
657 fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
658 self.read_header(strmgr)?;
662 #[allow(unused_variables)]
663 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
664 if !self.queued_pkts.is_empty() {
665 let pkt = self.queued_pkts.pop().unwrap();
669 if self.cur_packet >= self.num_packets {
670 if (self.next_data != 0) && (self.next_data == self.src.tell()) {
671 let res = read_chunk(self.src);
672 if let Ok((id, size, ver)) = res {
673 self.data_pos = self.src.tell();
675 if self.parse_data_start().is_ok() {
680 return Err(DemuxerError::EOF);
683 let pkt_start = self.src.tell();
684 let ver = self.src.read_u16be()?;
686 let len = self.src.read_u16be()? as usize;
687 let str_no = self.src.read_u16be()? as u32;
688 let ts = self.src.read_u32be()?;
692 pkt_grp = self.src.read_byte()? as u16;
693 flags = self.src.read_byte()?;
695 //asm_rule = self.src.read_u16be()?;
696 //asm_flags = self.src.read_byte()?;
697 self.src.read_skip(2)?;
699 self.src.read_skip(1)?;
702 let hdr_size = self.src.tell() - pkt_start;
703 //println!("packet @{:X} size {} for {} ts {} grp {} flags {:X}", pkt_start, len, str_no, ts, pkt_grp, flags);
704 self.cur_packet += 1;
706 let payload_size = len - (hdr_size as usize);
708 let stream_id = self.str_data.get_stream_id(str_no as u32, pkt_grp);
709 let sr = self.str_data.find_stream(stream_id);
711 //println!("stream {} not found", str_no);
712 self.src.read_skip(payload_size)?;
713 return Err(DemuxerError::InvalidData);
715 let str_id = sr.unwrap();
717 let streamres = strmgr.get_stream_by_id(stream_id);
718 if streamres.is_none() {
719 self.src.read_skip(payload_size)?;
722 let stream = streamres.unwrap();
723 //println!(" stream {}", str_id);
724 if strmgr.is_ignored_id(stream_id) {
725 self.src.read_skip(payload_size)?;
728 //todo skip unwanted packet
729 let keyframe = (flags & KEYFRAME_FLAG) != 0;
731 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);
732 if let Err(DemuxerError::TryAgain) = ret {
740 #[allow(unused_variables)]
741 fn seek(&mut self, time: u64) -> DemuxerResult<()> {
746 fn read_chunk(src: &mut ByteReader) -> DemuxerResult<(u32, u32, u16)> {
747 let id = src.read_u32be()?;
748 if id == 0 { return Ok((0, 0, 0)); }
749 let size = src.read_u32be()?;
751 let ver = src.read_u16be()?;
753 return Ok((id, 0x0FFFFFFF, ver));
755 validate!(size >= 10);
756 let ver = src.read_u16be()?;
761 #[derive(Clone,Copy,Debug)]
762 struct InterleaveInfo {
769 #[derive(Clone,Copy,Debug)]
770 struct RealAudioInfo {
778 bytes_per_minute: u32,
781 ileave_info: Option<InterleaveInfo>
784 fn skip_ra_metadata(src: &mut ByteReader) -> DemuxerResult<()> {
785 let title_len = src.read_byte()? as usize;
786 src.read_skip(title_len)?;
787 let author_len = src.read_byte()? as usize;
788 src.read_skip(author_len)?;
789 let copywrong_len = src.read_byte()? as usize;
790 src.read_skip(copywrong_len)?;
791 let comment_len = src.read_byte()? as usize;
792 src.read_skip(comment_len)?;
796 #[allow(unused_variables)]
797 fn parse_aformat3(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
798 let start = src.tell();
799 let header_len = src.read_u16be()?;
800 validate!(header_len >= 24);
801 let flavor = src.read_u16be()?;
802 let granularity = src.read_u32be()?;
803 let bytes_per_minute = src.read_u32be()?;
804 let total_bytes = src.read_u32be()?;
806 skip_ra_metadata(src)?;
808 let _can_copy = src.read_byte()?;
809 let fcc_len = src.read_byte()?;
810 validate!(fcc_len == 4);
811 let fcc = src.read_u32be()?;
813 let end = src.tell();
814 validate!(end - start <= (header_len as u64) + 2);
817 fcc: fcc, flavor: flavor,
818 sample_rate: 8000, sample_size: 16, channels: 1, channel_mask: 0,
819 granularity: granularity, bytes_per_minute: bytes_per_minute,
820 total_bytes: total_bytes, edata_size: 0,
825 #[allow(unused_variables)]
826 fn parse_aformat4(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
827 let start = src.tell();
828 src.read_skip(2)?; // zeroes
829 let id = src.read_u32be()?;
830 validate!(id == mktag!(b".ra4"));
831 let data_size = src.read_u32be()?;
832 let _ver4 = src.read_u16be()?; // should be 4
833 let header_size = src.read_u32be()?;
834 let flavor = src.read_u16be()?;
835 let granularity = src.read_u32be()?;
836 let total_bytes = src.read_u32be()?;
837 let bytes_per_minute = src.read_u32be()?;
838 let _bytes_per_minute2 = src.read_u32be()?;
839 let ileave_factor = src.read_u16be()?;
840 let ileave_block_size = src.read_u16be()?;
841 let _user_data = src.read_u16be()?;
842 let sample_rate = src.read_u32be()?;
843 let sample_size = src.read_u32be()?;
844 let channels = src.read_u16be()?;
845 let interleaver_id_len = src.read_byte()?;
846 validate!(interleaver_id_len == 4);
847 let interleaver_id = src.read_u32be()?;
848 let fcc_len = src.read_byte()?;
849 validate!(fcc_len == 4);
850 let fcc = src.read_u32be()?;
851 let is_interleaved = src.read_byte()?;
852 let _can_copy = src.read_byte()?;
853 let _stream_type = src.read_byte()?;
855 skip_ra_metadata(src)?;
857 let end = src.tell();
858 validate!(end - start <= (header_size as u64) + 10);
860 let ileave_info = if is_interleaved != 0 {
861 Some(InterleaveInfo {
862 id: interleaver_id, factor: ileave_factor, block_size: granularity as u16,
863 frame_size: ileave_block_size,
870 fcc: fcc, flavor: flavor,
871 sample_rate: sample_rate, sample_size: sample_size as u16, channels: channels, channel_mask: 0,
872 granularity: granularity, bytes_per_minute: bytes_per_minute,
873 total_bytes: total_bytes & 0xFFFFFF, edata_size: 0,
874 ileave_info: ileave_info,
878 #[allow(unused_variables)]
879 fn parse_aformat5(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
880 let start = src.tell();
881 src.read_skip(2)?; // zeroes
882 let id = src.read_u32be()?;
883 validate!((id == mktag!(b".ra5")) || (id == mktag!(b".ra4")));
884 let data_size = src.read_u32be()?;
885 let _ver5 = src.read_u16be()?; // should be 5
886 let header_size = src.read_u32be()?;
887 let flavor = src.read_u16be()?;
888 let granularity = src.read_u32be()?;
889 let total_bytes = src.read_u32be()?;
890 let bytes_per_minute = src.read_u32be()?;
891 let _bytes_per_minute2 = src.read_u32be()?;
892 let ileave_factor = src.read_u16be()?;
893 let frame_size = src.read_u16be()?;
894 let ileave_block_size = src.read_u16be()?;
895 let user_data = src.read_u32be()?;
896 let _sample_rate1 = src.read_u16be()?;
897 let sample_rate = src.read_u32be()?;
898 let sample_size = src.read_u32be()?;
899 let channels = src.read_u16be()?;
900 let interleaver_id = src.read_u32be()?;
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()?;
905 let has_ileave_pattern = src.read_byte()?;
906 if has_ileave_pattern != 0 {
907 unimplemented!("ra5 interleave pattern");
909 let mut edata_size = src.read_u32be()?;
910 let end = src.tell();
911 if id == mktag!(b".ra5") {
912 validate!(end - start <= (header_size as u64) + 10);
913 // src.read_skip(((end - start) as usize) - (header_size as usize) - 10)?;
915 validate!(end - start <= (header_size as u64) + 15);
918 let ileave_info = if is_interleaved != 0 {
919 Some(InterleaveInfo {
920 id: interleaver_id, factor: ileave_factor, block_size: ileave_block_size, frame_size: frame_size,
925 if (fcc == mktag!(b"raac")) || (fcc == mktag!(b"racp")) {
926 validate!(edata_size > 1);
932 fcc: fcc, flavor: flavor,
933 sample_rate: sample_rate, sample_size: sample_size as u16, channels: channels, channel_mask: 0,
934 granularity: granularity, bytes_per_minute: bytes_per_minute,
935 total_bytes: total_bytes & 0xFFFFFF, edata_size: edata_size,
936 ileave_info: ileave_info,
940 const RMVB_HDR_SIZE: u32 = 18;
941 const RMVB_PROP_SIZE: u32 = 50;
942 const KEYFRAME_FLAG: u8 = 0x02;
944 impl<'a> RealMediaDemuxer<'a> {
945 fn new(io: &'a mut ByteReader<'a>) -> Self {
953 str_data: CommonStreamData::new(),
954 queued_pkts: Vec::new(),
955 slice_buf: Vec::new(),
958 #[allow(unused_variables)]
959 fn read_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
960 let (id, size, ver) = read_chunk(self.src)?;
961 validate!((id == mktag!(b".RMF")) || (id == mktag!(b".RMP")));
962 validate!(size >= RMVB_HDR_SIZE);
963 let fver = self.src.read_u32be()?;
964 validate!(fver <= 1);
965 let num_hdr = self.src.read_u32be()? as usize;
966 validate!(num_hdr >= 1);
967 if size > RMVB_HDR_SIZE {
968 self.src.read_skip((size - RMVB_HDR_SIZE) as usize)?;
971 let (id, size, ver) = read_chunk(self.src)?;
972 let prop_size = if ver == 0 { RMVB_PROP_SIZE } else { RMVB_PROP_SIZE + 4 };
973 validate!(size >= prop_size);
974 validate!((ver == 0) || (ver == 2));
975 let maxbr = self.src.read_u32be()?;
976 let avgbr = self.src.read_u32be()?;
977 let maxps = self.src.read_u32be()?;
978 let avgps = self.src.read_u32be()?;
979 let num_pkt = self.src.read_u32be()? as usize;
980 let duration = self.src.read_u32be()?;
981 let preroll = self.src.read_u32be()?;
983 self.src.read_skip(4)?;
985 let idx_off = self.src.read_u32be()?;
986 let data_off = self.src.read_u32be()?;
987 let num_streams = self.src.read_u16be()? as usize;
988 let flags = self.src.read_u16be()?;
989 if size > prop_size {
990 self.src.read_skip((size - prop_size) as usize)?;
993 for _ in 0..num_hdr {
994 if self.src.is_eof() {
998 let res = self.parse_chunk(strmgr);
1000 Ok(last) => { if last { break; } },
1001 Err(DemuxerError::IOError) => { break; },
1003 if self.data_pos == 0 { // data is not found, report error
1009 //println!("now @ {:X} / {}", self.src.tell(), self.data_pos);
1010 validate!(self.data_pos > 0);
1011 self.src.seek(SeekFrom::Start(self.data_pos))?;
1012 self.parse_data_start()?;
1015 fn parse_data_start(&mut self) -> DemuxerResult<()> {
1016 let num_packets = self.src.read_u32be()?;
1017 if self.data_ver == 2 {
1018 self.src.read_skip(12)?; // zeroes?
1020 let next_data_hdr = self.src.read_u32be()?;
1021 self.num_packets = if num_packets > 0 { num_packets } else { 0xFFFFFF };
1022 self.cur_packet = 0;
1023 self.next_data = next_data_hdr as u64;
1026 fn parse_chunk(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<bool> {
1027 let (id, size, ver) = read_chunk(self.src)?;
1028 let end_pos = self.src.tell() - 10 + (size as u64);
1030 validate!((ver == 0) || (ver == 2));
1031 if id == mktag!(b"CONT") { self.parse_content_desc()?; }
1032 else if id == mktag!(b"MDPR") { self.parse_mdpr(strmgr)?; }
1033 else if id == mktag!(b"DATA") { if self.data_pos == 0 { self.data_ver = ver; self.data_pos = self.src.tell(); } }
1034 else if id == mktag!(b"INDX") { /* do nothing for now */ }
1035 else if id == 0 { return Ok(true); }
1036 else { println!("unknown chunk type {:08X}", id); }
1038 let cpos = self.src.tell();
1040 self.src.read_skip((end_pos - cpos) as usize)?;
1044 #[allow(unused_variables)]
1045 fn parse_content_desc(&mut self) -> DemuxerResult<()> {
1046 let title_len = self.src.read_u16be()? as usize;
1047 self.src.read_skip(title_len)?;
1048 let author_len = self.src.read_u16be()? as usize;
1049 self.src.read_skip(author_len)?;
1050 let copywrong_len = self.src.read_u16be()? as usize;
1051 self.src.read_skip(copywrong_len)?;
1052 let comment_len = self.src.read_u16be()? as usize;
1053 self.src.read_skip(comment_len)?;
1056 #[allow(unused_variables)]
1057 fn parse_mdpr(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
1058 let stream_no = self.src.read_u16be()? as u32;
1059 //todo check stream_no for duplicates
1060 let maxbr = self.src.read_u32be()?;
1061 let avgbr = self.src.read_u32be()?;
1062 let maxps = self.src.read_u32be()?;
1063 let avgps = self.src.read_u32be()?;
1064 let start = self.src.read_u32be()?;
1065 let preroll = self.src.read_u32be()?;
1066 let duration = self.src.read_u32be()?;
1067 let sname_size = self.src.read_byte()? as usize;
1068 let sname = read_string_size(self.src, sname_size)?;
1069 //println!("str #{} sname = {} pkts {}/{} start {} preroll {}", stream_no, sname, maxps, avgps, start, preroll);
1070 let mime_size = self.src.read_byte()? as usize;
1071 let mime = read_string_size(self.src, mime_size)?;
1072 //println!("mime = {}", mime);
1073 let edata_size = self.src.read_u32be()? as usize;
1074 let edata: Option<Vec<u8>> = if edata_size == 0 { None } else {
1075 let mut edvec: Vec<u8> = Vec::with_capacity(edata_size);
1076 edvec.resize(edata_size, 0);
1077 self.src.read_buf(&mut edvec)?;
1080 let mut is_mlti = false;
1082 if let Some(edata_) = edata {
1083 is_mlti = RMDemuxCommon::parse_stream_info(&mut self.str_data, strmgr, stream_no, &edata_)?;
1086 self.str_data.streams.push(RMStreamType::Unknown);
1089 self.str_data.str_ids.push(stream_no);
1094 /*#[allow(unused_variables)]
1095 fn read_pkt_header(&mut self) -> DemuxerResult<()> {
1096 let ver = self.src.read_u16be()?;
1097 validate!(ver <= 1);
1098 let str_no = self.src.read_u16be()?;
1099 let timestamp = self.src.read_u32be()?;
1101 let pkt_group = self.src.read_byte()?;
1102 let pkt_flags = self.src.read_byte()?;
1104 let asm_rule = self.src.read_u16be()?;
1105 let asm_flags = self.src.read_byte()?;
1111 fn read_string(src: &mut ByteReader) -> DemuxerResult<String> {
1112 let mut vec: Vec<u8> = Vec::new();
1114 let c = src.read_byte()?;
1115 if c == 0 { break; }
1118 let str = String::from_utf8(vec);
1126 fn read_string_size(src: &mut ByteReader, size: usize) -> DemuxerResult<String> {
1127 let mut vec: Vec<u8> = Vec::new();
1129 let c = src.read_byte()?;
1132 let str = String::from_utf8(vec);
1141 #[allow(unused_variables)]
1142 fn parse_rm_stream(io: &mut ByteReader) -> DemuxerResult<NAStream> {
1143 let mimetype = read_string(io)?;
1144 let strname = read_string(io)?;
1145 let strnum = io.read_u32be()?;
1146 let maxbr = io.read_u32be()?;
1147 let avgbr = io.read_u32be()?;
1148 let maxsize = io.read_u32be()?;
1149 let avgsize = io.read_u32be()?;
1150 let duration = io.read_u32be()?;
1151 let preroll = io.read_u32be()?;
1152 let start = io.read_u32be()?;
1153 let edatalen = io.read_u32be()? as usize;
1154 let mut edata: Vec<u8> = Vec::with_capacity(edatalen);
1155 edata.resize(edatalen, 0);
1156 io.read_buf(&mut edata)?;
1157 let numprops = io.read_u32be()? as usize;
1162 struct RealAudioDemuxer<'a> {
1163 src: &'a mut ByteReader<'a>,
1164 stream: Option<RMAudioStream>,
1168 queued_pkts: Vec<NAPacket>,
1171 impl<'a> DemuxCore<'a> for RealAudioDemuxer<'a> {
1172 #[allow(unused_variables)]
1173 fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
1174 let magic = self.src.read_u32be()?;
1175 validate!(magic == mktag!(b".ra\xFD"));
1176 let ver = self.src.read_u16be()?;
1177 let ainfo = match ver {
1179 parse_aformat3(&mut self.src)?
1182 parse_aformat4(&mut self.src)?
1185 parse_aformat5(&mut self.src)?
1188 println!("unknown version {}", ver);
1189 return Err(DemuxerError::InvalidData);
1192 println!(" got ainfo {:?}", ainfo);
1193 let cname = find_codec_name(RM_AUDIO_CODEC_REGISTER, ainfo.fcc);
1194 let blk_size = if ainfo.fcc != mktag!(b"sipr") {
1195 ainfo.granularity as usize
1197 validate!(ainfo.flavor <= 3);
1198 RM_SIPRO_BLOCK_SIZES[ainfo.flavor as usize]
1200 let srate = ainfo.sample_rate;
1201 let soniton = NASoniton::new(ainfo.sample_size as u8, SONITON_FLAG_SIGNED);
1202 let ahdr = NAAudioInfo::new(srate, ainfo.channels as u8, soniton, blk_size);
1203 let extradata = if ainfo.edata_size == 0 {
1206 let mut dta: Vec<u8> = Vec::with_capacity(ainfo.edata_size as usize);
1207 dta.resize(ainfo.edata_size as usize, 0);
1208 self.src.read_buf(dta.as_mut_slice())?;
1211 let nainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
1212 let res = strmgr.add_stream(NAStream::new(StreamType::Audio, 0, nainfo, 1, srate));
1213 if res.is_none() { return Err(MemoryError); }
1215 let astr = RMAudioStream::new(ainfo.ileave_info);
1216 self.data_start = self.src.tell();
1217 self.data_end = if ainfo.total_bytes > 0 { self.src.tell() + (ainfo.total_bytes as u64) } else { 0 };
1218 self.blk_size = blk_size;
1219 self.stream = Some(astr);
1224 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
1225 if !self.queued_pkts.is_empty() {
1226 let pkt = self.queued_pkts.pop().unwrap();
1229 if (self.data_end != 0) && (self.src.tell() >= self.data_end) {
1230 return Err(DemuxerError::EOF);
1232 let streamres = strmgr.get_stream_by_id(0);
1233 let stream = streamres.unwrap();
1234 if let Some(ref mut astr) = self.stream {
1236 let ret = astr.read_apackets(&mut self.queued_pkts, &mut self.src, stream.clone(), 0, false, self.blk_size);
1237 if let Err(DemuxerError::TryAgain) = ret {
1243 Err(DemuxerError::NoSuchInput)
1246 #[allow(unused_variables)]
1247 fn seek(&mut self, time: u64) -> DemuxerResult<()> {
1252 impl<'a> RealAudioDemuxer<'a> {
1253 fn new(io: &'a mut ByteReader<'a>) -> Self {
1260 queued_pkts: Vec::new(),
1267 StreamProperties(usize),
1268 Packet { ts: u32, str: u32, flags: u32, len: usize, checksum: u32 },
1269 IntValue(Vec<u8>, u32),
1270 BinaryData(Vec<u8>, Vec<u8>),
1271 StringData(Vec<u8>, Vec<u8>),
1278 fn read_string(src: &mut ByteReader) -> DemuxerResult<Vec<u8>> {
1279 let len = src.read_u32be()? as usize;
1280 let mut val = Vec::with_capacity(len);
1282 src.read_buf(val.as_mut_slice())?;
1286 fn read(src: &mut ByteReader) -> DemuxerResult<Self> {
1287 let code = src.read_byte()?;
1290 let val = src.read_u32be()? as usize;
1291 Ok(IVRRecord::StreamProperties(val))
1294 let ts = src.read_u32be()?;
1295 let str = src.read_u16be()? as u32;
1296 let flags = src.read_u32be()?;
1297 let len = src.read_u32be()? as usize;
1298 let chk = src.read_u32be()?;
1299 Ok(IVRRecord::Packet { ts, str, flags, len, checksum: chk })
1302 let name = Self::read_string(src)?;
1303 let len = src.read_u32be()?;
1304 validate!(len == 4);
1305 let val = src.read_u32be()?;
1306 Ok(IVRRecord::IntValue(name, val))
1309 let name = Self::read_string(src)?;
1310 let len = src.read_u32be()? as usize;
1311 let mut val = Vec::with_capacity(len);
1313 src.read_buf(val.as_mut_slice())?;
1314 Ok(IVRRecord::BinaryData(name, val))
1317 let name = Self::read_string(src)?;
1318 let val = Self::read_string(src)?;
1319 Ok(IVRRecord::StringData(name, val))
1321 6 => Ok(IVRRecord::HeaderEnd),
1323 src.read_skip(8)?; // always zero?
1324 Ok(IVRRecord::DataEnd)
1327 src.read_skip(8)?; // always zero?
1328 Ok(IVRRecord::DataStart)
1330 _ => Ok(IVRRecord::Invalid(code)),
1333 fn is_data_start(&self) -> bool {
1335 IVRRecord::DataStart => true,
1341 impl fmt::Display for IVRRecord {
1342 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1344 IVRRecord::Invalid(typ) => write!(f, "Invalid({:02X})", typ),
1345 IVRRecord::StreamProperties(num) =>
1346 write!(f, "({} stream properties)", num),
1347 IVRRecord::Packet { ts, str, flags, len, checksum } =>
1348 write!(f, "paket({}, {}, {:X}, {}, {})", ts, str, flags, len, checksum),
1349 IVRRecord::IntValue(ref name, val) =>
1350 write!(f, "({} = {})", String::from_utf8_lossy(name), val),
1351 IVRRecord::BinaryData(ref name, ref val) =>
1352 write!(f, "({} = {} bytes)", String::from_utf8_lossy(name), val.len()),
1353 IVRRecord::StringData(ref name, ref val) =>
1354 write!(f, "({} = {})", String::from_utf8_lossy(name), String::from_utf8_lossy(val)),
1355 IVRRecord::HeaderEnd => write!(f, "header end"),
1356 IVRRecord::DataEnd => write!(f, "data end"),
1357 IVRRecord::DataStart => write!(f, "data start"),
1362 struct RecordDemuxer {
1366 remap_ids: Vec<u32>,
1369 impl RecordDemuxer {
1370 fn new(pos: u64, start_str: u32) -> Self {
1374 start_str: start_str,
1375 remap_ids: Vec::new(),
1378 fn parse_header(&mut self, src: &mut ByteReader, strmgr: &mut StreamManager, str_data: &mut CommonStreamData) -> DemuxerResult<()> {
1379 src.seek(SeekFrom::Start(self.cur_pos))?;
1380 let magic = src.read_u32be()?;
1381 validate!(magic == mktag!(b".REC"));
1382 let _smth = src.read_byte()?;
1383 let num_entries = src.read_u32be()? as usize;
1384 for _ in 0..num_entries {
1385 let _rec = IVRRecord::read(src)?;
1386 //println!(" header rec {}", _rec);
1388 let mut has_seek_table = false;
1389 let mut cur_str_no = 0;
1391 let rec = IVRRecord::read(src)?;
1393 IVRRecord::HeaderEnd => { break; },
1394 IVRRecord::StreamProperties(num) => {
1395 let stream_no = cur_str_no + self.start_str;
1397 let mut parsed = false;
1398 let mut real_stream_no = 0;
1400 let rec = IVRRecord::read(src)?;
1401 //println!(" strm property {}", rec);
1403 IVRRecord::IntValue(ref name, val) => {
1404 if name == b"StreamNumber\0" {
1405 real_stream_no = val;
1408 IVRRecord::BinaryData(ref name, ref val) => {
1409 if name == b"OpaqueData\0" {
1411 let is_mlti = RMDemuxCommon::parse_stream_info(str_data, strmgr, stream_no, val)?;
1413 str_data.str_ids.push(stream_no);
1418 IVRRecord::StringData(ref name, ref val) => {
1419 if (name == b"SeekType\0") && (val != b"None\0") {
1420 has_seek_table = true;
1423 _ => { return Err(DemuxerError::InvalidData); }
1427 str_data.streams.push(RMStreamType::Unknown);
1428 str_data.str_ids.push(stream_no);
1430 self.remap_ids.push(real_stream_no);
1432 _ => {println!(" unexpected {}", rec); return Err(DemuxerError::InvalidData); }
1435 println!(" now @ {:X}", src.tell());
1436 let off0 = src.read_u32be()? as u64;
1437 let _off1 = src.read_u32be()?;
1438 let _off2 = src.read_u32be()?;
1439 validate!(off0 + self.start_pos == src.tell());
1440 println!(" has seek tab: {}", has_seek_table);
1443 let data_off = src.read_u32be()? as u64;
1444 println!(" new off {:X}", data_off);
1445 let pos = src.tell();
1446 validate!(data_off + self.start_pos > pos);
1447 src.read_skip((data_off + self.start_pos - pos) as usize)?;
1448 let rec = IVRRecord::read(src)?;
1449 validate!(rec.is_data_start());
1451 let ntype = src.peek_byte()?;
1452 validate!((ntype == 2) || (ntype == 7)); // packet or data end, no start
1455 self.cur_pos = src.tell();
1459 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> {
1460 src.seek(SeekFrom::Start(self.cur_pos))?;
1462 let rec = IVRRecord::read(src)?;
1464 IVRRecord::Packet { ts, str, flags: _, len, checksum: _ } => {
1465 let payload_size = len;
1466 let sr = self.remap_ids.iter().position(|x| *x == str);
1467 validate!(sr.is_some());
1468 let str_no = self.start_str + (sr.unwrap() as u32);
1469 let stream_id = str_data.get_stream_id(str_no as u32, 0/*pkt_grp*/);
1470 let sr = str_data.find_stream(stream_id);
1472 src.read_skip(payload_size)?;
1473 return Err(DemuxerError::InvalidData);
1475 let str_id = sr.unwrap();
1477 let streamres = strmgr.get_stream_by_id(stream_id);
1478 if streamres.is_none() {
1479 src.read_skip(payload_size)?;
1482 let stream = streamres.unwrap();
1483 if strmgr.is_ignored_id(stream_id) {
1484 src.read_skip(payload_size)?;
1487 let keyframe = false;
1488 let ret = RMDemuxCommon::parse_packet_payload(src, &mut str_data.streams[str_id], stream, slice_buf, queued_pkts, keyframe, ts, payload_size);
1489 if let Err(DemuxerError::TryAgain) = ret {
1492 self.cur_pos = src.tell();
1496 IVRRecord::DataEnd => return Err(DemuxerError::EOF),
1497 _ => return Err(DemuxerError::InvalidData),
1503 struct RealIVRDemuxer<'a> {
1504 src: &'a mut ByteReader<'a>,
1505 recs: Vec<RecordDemuxer>,
1507 queued_pkts: Vec<NAPacket>,
1509 str_data: CommonStreamData,
1512 impl<'a> DemuxCore<'a> for RealIVRDemuxer<'a> {
1513 #[allow(unused_variables)]
1514 fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
1515 let magic = self.src.peek_u32be()?;
1516 if magic == mktag!(b".REC") {
1517 let mut rec = RecordDemuxer::new(0, 0);
1518 rec.parse_header(&mut self.src, strmgr, &mut self.str_data)?;
1519 self.recs.push(rec);
1520 } else if magic == mktag!(b".R1M") {
1521 println!("R1M kind");
1522 self.src.read_skip(4)?; // magic
1523 self.src.read_skip(3)?; // always 0, 1, 1 ?
1524 let _name = IVRRecord::read_string(&mut self.src)?;
1525 self.src.read_skip(1)?; // always 0?
1526 let len1 = self.src.read_u32be()? as u64;
1527 let off1 = self.src.read_u64be()?;
1528 let cpos = self.src.tell();
1529 validate!(off1 == len1 + cpos - 8);
1530 self.src.read_skip((off1 - cpos) as usize)?;
1532 let typ = self.src.read_byte()?;
1533 println!(" at {:X} type {:02X}", self.src.tell(), typ);
1536 let len = self.src.read_u32be()?;
1537 self.src.read_skip(len as usize)?;
1540 let len = self.src.read_u32be()? as u64;
1541 let pos = self.src.tell();
1542 let num_streams = self.str_data.streams.len() as u32;
1543 let mut rec = RecordDemuxer::new(pos + 12, num_streams);
1544 rec.parse_header(&mut self.src, strmgr, &mut self.str_data)?;
1545 self.recs.push(rec);
1546 self.src.seek(SeekFrom::Start(pos + len))?;
1549 let mut buf: [u8; 2] = [0; 2];
1550 self.src.peek_buf(&mut buf)?;
1551 if (buf[0] == b'J') && (buf[1] == b'M') { // RJMx markers at the end of file
1554 return Err(DemuxerError::InvalidData);
1557 _ => { return Err(DemuxerError::InvalidData); },
1561 return Err(DemuxerError::InvalidData);
1567 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
1568 if !self.queued_pkts.is_empty() {
1569 let pkt = self.queued_pkts.pop().unwrap();
1573 if self.cur_rec >= self.recs.len() { return Err(DemuxerError::EOF); }
1574 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);
1575 if let Err(DemuxerError::EOF) = res {
1583 #[allow(unused_variables)]
1584 fn seek(&mut self, time: u64) -> DemuxerResult<()> {
1589 impl<'a> RealIVRDemuxer<'a> {
1590 fn new(io: &'a mut ByteReader<'a>) -> Self {
1595 queued_pkts: Vec::new(),
1596 slice_buf: Vec::new(),
1597 str_data: CommonStreamData::new(),
1602 static RM_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
1603 (b"RV10", "realvideo1"),
1604 (b"RV20", "realvideo2"),
1605 (b"RVTR", "realvideo2"),
1606 (b"RV30", "realvideo3"),
1607 (b"RV40", "realvideo4"),
1608 (b"RV60", "realvideo6"),
1609 (b"CLV1", "clearvideo_rm"),
1613 static RM_AUDIO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
1614 (b"lpcJ", "ra14.4"),
1615 (b"28_8", "ra28.8"),
1619 (b"atrc", "atrac3"),
1625 pub struct RealMediaDemuxerCreator { }
1627 impl DemuxerCreator for RealMediaDemuxerCreator {
1628 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
1629 Box::new(RealMediaDemuxer::new(br))
1631 fn get_name(&self) -> &'static str { "realmedia" }
1634 pub struct RealAudioDemuxerCreator { }
1636 impl DemuxerCreator for RealAudioDemuxerCreator {
1637 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
1638 Box::new(RealAudioDemuxer::new(br))
1640 fn get_name(&self) -> &'static str { "realaudio" }
1643 pub struct RealIVRDemuxerCreator { }
1645 impl DemuxerCreator for RealIVRDemuxerCreator {
1646 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
1647 Box::new(RealIVRDemuxer::new(br))
1649 fn get_name(&self) -> &'static str { "real_ivr" }
1658 fn test_rm_demux() {
1660 File::open("assets/RV/rv10_dnet_640x352_realvideo_encoder_4.0.rm").unwrap();
1661 // File::open("assets/RV/rv20_cook_640x352_realproducer_plus_8.51.rm").unwrap();
1662 // File::open("assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm").unwrap();
1663 // File::open("assets/RV/rv30_atrc_384x208_realproducer_plus_8.51.rm").unwrap();
1664 // File::open("assets/RV/rv30_chroma_drift.rm").unwrap();
1665 // File::open("assets/RV/rv30_weighted_mc.rm").unwrap();
1666 // File::open("assets/RV/rv40_weighted_mc.rmvb").unwrap();
1667 // File::open("assets/RV/rv40_weighted_mc_2.rmvb").unwrap();
1668 // File::open("assets/RV/clv1_sipr_384x208_realvideo_encoder_4.0.rm").unwrap();
1669 // File::open("assets/RV/luckynight.rmvb").unwrap();
1670 // File::open("assets/RV/rv40_ralf.rmvb").unwrap();
1671 let mut fr = FileReader::new_read(&mut file);
1672 let mut br = ByteReader::new(&mut fr);
1673 let mut dmx = RealMediaDemuxer::new(&mut br);
1674 let mut sm = StreamManager::new();
1675 dmx.open(&mut sm).unwrap();
1678 let pktres = dmx.get_frame(&mut sm);
1679 if let Err(e) = pktres {
1680 if e == DemuxerError::EOF { break; }
1683 let pkt = pktres.unwrap();
1684 println!("Got {}", pkt);
1686 //panic!("the end");
1689 fn test_ra_demux() {
1691 // File::open("assets/RV/welcome288.ra").unwrap();
1692 File::open("assets/RV/diemusik.ra").unwrap();
1693 let mut fr = FileReader::new_read(&mut file);
1694 let mut br = ByteReader::new(&mut fr);
1695 let mut dmx = RealAudioDemuxer::new(&mut br);
1696 let mut sm = StreamManager::new();
1697 dmx.open(&mut sm).unwrap();
1700 let pktres = dmx.get_frame(&mut sm);
1701 if let Err(e) = pktres {
1702 if e == DemuxerError::EOF { break; }
1705 let pkt = pktres.unwrap();
1706 println!("Got {}", pkt);
1710 fn test_ivr_demux() {
1712 File::open("assets/RV/Opener_rm_hi.ivr").unwrap();
1713 // File::open("assets/RV/SherwinWilliamsCommercial.ivr").unwrap();
1714 let mut fr = FileReader::new_read(&mut file);
1715 let mut br = ByteReader::new(&mut fr);
1716 let mut dmx = RealIVRDemuxer::new(&mut br);
1717 let mut sm = StreamManager::new();
1718 dmx.open(&mut sm).unwrap();
1721 let pktres = dmx.get_frame(&mut sm);
1722 if let Err(e) = pktres {
1723 if e == DemuxerError::EOF { break; }
1726 let pkt = pktres.unwrap();
1727 println!("Got {}", pkt);