2 use super::DemuxerError::*;
10 ($a:expr, $b:expr, $c:expr, $d:expr) => ({
11 (($a as u32) << 24) | (($b as u32) << 16) | (($c as u32) << 8) | ($d as u32)
14 (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
18 const RM_SIPRO_BLOCK_SIZES: [usize; 4] = [ 29, 19, 37, 20 ];
19 const RM_SIPRO_SWAPS: [[u8; 2]; 38] = [
20 [ 0, 63 ], [ 1, 22 ], [ 2, 44 ], [ 3, 90 ],
21 [ 5, 81 ], [ 7, 31 ], [ 8, 86 ], [ 9, 58 ],
22 [ 10, 36 ], [ 12, 68 ], [ 13, 39 ], [ 14, 73 ],
23 [ 15, 53 ], [ 16, 69 ], [ 17, 57 ], [ 19, 88 ],
24 [ 20, 34 ], [ 21, 71 ], [ 24, 46 ], [ 25, 94 ],
25 [ 26, 54 ], [ 28, 75 ], [ 29, 50 ], [ 32, 70 ],
26 [ 33, 92 ], [ 35, 74 ], [ 38, 85 ], [ 40, 56 ],
27 [ 42, 87 ], [ 43, 65 ], [ 45, 59 ], [ 48, 79 ],
28 [ 49, 93 ], [ 51, 89 ], [ 55, 95 ], [ 61, 76 ],
29 [ 67, 83 ], [ 77, 80 ]
32 struct RMVideoStream {
49 self.frame.truncate(0);
53 fn start_slice(&mut self, num_slices: usize, frame_size: usize, data: &[u8]) {
54 self.hdr_size = num_slices * 8 + 1;
55 self.frame.resize(frame_size + self.hdr_size, 0);
56 self.frame[0] = (num_slices - 1) as u8;
58 self.add_slice(1, data);
60 fn add_slice(&mut self, slice_no: usize, data: &[u8]) {
61 self.write_slice_info(slice_no);
62 let dslice = &mut self.frame[self.hdr_size + self.frame_pos..][..data.len()];
63 dslice.copy_from_slice(data);
64 self.frame_pos += data.len();
66 fn write_slice_info(&mut self, slice_no: usize) {
67 let off = 1 + (slice_no - 1) * 8;
68 self.frame[off + 0] = 0;
69 self.frame[off + 1] = 0;
70 self.frame[off + 2] = 0;
71 self.frame[off + 3] = 1;
72 self.frame[off + 4] = (self.frame_pos >> 24) as u8;
73 self.frame[off + 5] = (self.frame_pos >> 16) as u8;
74 self.frame[off + 6] = (self.frame_pos >> 8) as u8;
75 self.frame[off + 7] = (self.frame_pos >> 0) as u8;
77 fn get_frame_data(&mut self) -> Vec<u8> {
78 let mut v: Vec<u8> = Vec::new();
79 mem::swap(&mut v, &mut self.frame);
86 #[derive(Clone,Copy,PartialEq)]
96 struct RMAudioStream {
98 iinfo: Option<InterleaveInfo>,
103 const RM_ILEAVE_INT0: u32 = mktag!(b"Int0");
104 const RM_ILEAVE_INT4: u32 = mktag!(b"Int4");
105 const RM_ILEAVE_GENR: u32 = mktag!(b"genr");
106 const RM_ILEAVE_SIPR: u32 = mktag!(b"sipr");
107 const RM_ILEAVE_VBRF: u32 = mktag!(b"vbrf");
108 const RM_ILEAVE_VBRS: u32 = mktag!(b"vbrs");
111 fn new(iinfo: Option<InterleaveInfo>) -> Self {
113 let mut buf: Vec<u8>;
114 if let Some(info) = iinfo {
115 deint = match info.id {
116 RM_ILEAVE_INT0 => Deinterleaver::None,
117 RM_ILEAVE_INT4 => Deinterleaver::RA28_8,
118 RM_ILEAVE_GENR => Deinterleaver::Generic,
119 RM_ILEAVE_SIPR => Deinterleaver::Sipro,
120 RM_ILEAVE_VBRF => Deinterleaver::VBR,
121 RM_ILEAVE_VBRS => Deinterleaver::VBR,
122 _ => {println!("unknown deint {:X}", info.id); Deinterleaver::None },
125 Deinterleaver::None => { buf = Vec::new(); },
126 Deinterleaver::RA28_8 |
127 Deinterleaver::Generic |
128 Deinterleaver::Sipro => {
129 let bsize = (info.frame_size as usize) * (info.factor as usize);
130 buf = Vec::with_capacity(bsize);
131 buf.resize(bsize, 0u8);
133 Deinterleaver::VBR => {
138 deint = Deinterleaver::None;
141 RMAudioStream { deint: deint, iinfo: iinfo, buf: buf, sub_packet: 0 }
143 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> {
144 let (tb_num, tb_den) = stream.get_timebase();
145 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
151 Deinterleaver::None => { return src.read_packet(stream, ts, keyframe, payload_size); },
152 Deinterleaver::RA28_8 => {
153 let iinfo = self.iinfo.unwrap();
154 let factor = iinfo.factor as usize;
155 let halffact = factor >> 1;
156 let fsize = iinfo.frame_size as usize;
157 let bsize = iinfo.block_size as usize;
158 let ppos = self.sub_packet;
159 for sb in 0..halffact {
160 let mut dst = &mut self.buf[sb * 2 * fsize + ppos * bsize..][..bsize];
161 src.read_buf(&mut dst)?;
163 self.sub_packet += 1;
164 if self.sub_packet == factor {
166 return Ok(NAPacket::new(stream, ts, true, self.buf.clone()));
168 return Err(DemuxerError::TryAgain);
171 Deinterleaver::Generic => {
172 let iinfo = self.iinfo.unwrap();
173 let factor = iinfo.factor as usize;
174 let fsize = iinfo.frame_size as usize;
175 let bsize = iinfo.block_size as usize;
176 let factor2 = fsize / bsize;
177 let ppos = self.sub_packet;
179 for sb in 0..factor2 {
180 let sb_pos = factor * sb + ((factor + 1) >> 1) * (ppos & 1) + (ppos >> 1);
181 let mut dst = &mut self.buf[bsize * sb_pos..][..bsize];
182 src.read_buf(&mut dst)?;
185 Deinterleaver::Sipro => {
186 let iinfo = self.iinfo.unwrap();
187 let fsize = iinfo.frame_size as usize;
188 let ppos = self.sub_packet;
190 let mut dst = &mut self.buf[fsize * ppos..][..fsize];
191 src.read_buf(&mut dst)?;
193 Deinterleaver::VBR => {
194 validate!(payload_size >= 5);
195 let hdrsizesize = src.read_u16be()?;
196 let num_entries = (hdrsizesize / 16) as usize;
197 validate!(payload_size >= num_entries * 3 + 2);
198 let mut sizes: Vec<usize> = Vec::with_capacity(num_entries);
199 let mut tot_size = 0;
200 for _ in 0..num_entries {
201 let sz = src.read_u16be()? as usize;
205 validate!(tot_size + num_entries * 2 + 2 == payload_size);
206 let pkt_ts = NATimeInfo::new(None, None, None, tb_num, tb_den);
207 let mut first = true;
208 for size in sizes.iter() {
209 let cur_ts = if first { ts } else { pkt_ts };
211 let pkt = src.read_packet(stream.clone(), cur_ts, true, *size)?;
212 queued_packets.push(pkt);
214 queued_packets.reverse();
215 let pkt0 = queued_packets.pop().unwrap();
220 let iinfo = self.iinfo.unwrap();
221 let factor = iinfo.factor as usize;
222 let fsize = if iinfo.block_size != 0 { iinfo.block_size } else { iinfo.frame_size } as usize;
224 self.sub_packet += 1;
225 if self.sub_packet < factor {
226 return Err(DemuxerError::TryAgain);
231 if self.deint == Deinterleaver::Sipro {
232 sipro_restore(&mut self.buf, factor, fsize);
235 let mut frames_iter = self.buf.chunks(fsize);
236 let pkt0 = frames_iter.next().unwrap();
238 let pkt_ts = NATimeInfo::new(None, None, None, tb_num, tb_den);
239 for pkts in frames_iter {
240 let pkt = NAPacket::new(stream.clone(), pkt_ts, true, pkts.to_vec());
241 queued_packets.push(pkt);
243 queued_packets.reverse();
244 Ok(NAPacket::new(stream, ts, true, pkt0.to_vec()))
248 fn sipro_restore(buf: &mut [u8], factor: usize, fsize: usize) {
249 let stride = factor * fsize * 2 / 96;
251 let mut sidx = (RM_SIPRO_SWAPS[i][0] as usize) * stride;
252 let mut didx = (RM_SIPRO_SWAPS[i][1] as usize) * stride;
254 let in0 = buf[sidx >> 1];
255 let in1 = buf[didx >> 1];
256 let nib0 = (in0 >> ((sidx & 1) * 4)) & 0xF;
257 let nib1 = (in1 >> ((didx & 1) * 4)) & 0xF;
259 buf[didx >> 1] = (nib0 << (4 * (didx & 1))) | (in1 & (0xF << (4 * (!didx & 1))));
260 buf[sidx >> 1] = (nib1 << (4 * (sidx & 1))) | (in0 & (0xF << (4 * (!sidx & 1))));
269 Audio(RMAudioStream),
270 Video(RMVideoStream),
275 struct RealMediaDemuxer<'a> {
276 src: &'a mut ByteReader<'a>,
283 streams: Vec<RMStreamType>,
286 queued_pkts: Vec<NAPacket>,
290 fn find_codec_name(registry: &[(&[u8;4], &'static str)], fcc: u32) -> &'static str {
291 for &(fourcc, name) in registry {
292 if mktag!(fourcc) == fcc { return name; }
297 fn read_14or30(src: &mut ByteReader) -> DemuxerResult<(bool, u32)> {
298 let tmp = src.read_u16be()?;
299 let flag = (tmp & 0x8000) != 0;
300 if (tmp & 0x4000) == 0x4000 {
301 Ok((flag, ((tmp & 0x3FFF) as u32)))
303 let val = ((tmp as u32) << 16) | (src.read_u16be()? as u32);
304 Ok((flag, val & 0x3FFFFFFF))
308 fn read_video_buf(src: &mut ByteReader, stream: Rc<NAStream>, ts: u32, keyframe: bool, frame_size: usize) -> DemuxerResult<NAPacket> {
309 let size = (frame_size as usize) + 9;
310 let mut vec: Vec<u8> = Vec::with_capacity(size);
312 //v[0] = 0; // 1 slice
314 src.read_buf(&mut vec[9..])?;
316 let (tb_num, tb_den) = stream.get_timebase();
317 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
318 Ok(NAPacket::new(stream, ts, keyframe, vec))
321 fn read_multiple_frame(src: &mut ByteReader, stream: Rc<NAStream>, keyframe: bool, skip_mtype: bool) -> DemuxerResult<NAPacket> {
323 let mtype = src.read_byte()?;
324 validate!(mtype == 0xC0);
326 let (_, frame_size) = read_14or30(src)?;
327 let (_, timestamp) = read_14or30(src)?;
328 let _seq_no = src.read_byte()?;
329 //println!(" multiple frame size {} ts {} seq {}", frame_size, timestamp, seq_no);
331 read_video_buf(src, stream, timestamp, keyframe, frame_size as usize)
334 impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> {
335 #[allow(unused_variables)]
336 fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
337 self.read_header(strmgr)?;
341 #[allow(unused_variables)]
342 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
343 if !self.queued_pkts.is_empty() {
344 let pkt = self.queued_pkts.pop().unwrap();
348 if self.cur_packet >= self.num_packets {
349 if (self.next_data != 0) && (self.next_data == self.src.tell()) {
350 let res = read_chunk(self.src);
351 if let Ok((id, size, ver)) = res {
352 self.data_pos = self.src.tell();
354 if self.parse_data_start().is_ok() {
359 return Err(DemuxerError::EOF);
362 let pkt_start = self.src.tell();
363 let ver = self.src.read_u16be()?;
365 let len = self.src.read_u16be()? as usize;
366 let str_no = self.src.read_u16be()?;
367 let ts = self.src.read_u32be()?;
371 _pkt_grp = self.src.read_byte()?;
372 flags = self.src.read_byte()?;
374 //asm_rule = self.src.read_u16be()?;
375 self.src.read_skip(2)?;
377 self.src.read_skip(1)?;
380 let hdr_size = self.src.tell() - pkt_start;
381 //println!("packet @{:X} size {} for {} ts {} grp {} flags {:X}", pkt_start, len, str_no, ts, _pkt_grp, flags);
382 self.cur_packet += 1;
384 let payload_size = len - (hdr_size as usize);
386 let sr = self.str_ids.iter().position(|x| *x == str_no);
388 //println!("stream {} not found", str_no);
389 self.src.read_skip(payload_size)?;
390 return Err(DemuxerError::InvalidData);
392 let str_id = sr.unwrap();
393 let streamres = strmgr.get_stream_by_id(str_no as u32);
394 if streamres.is_none() {
395 self.src.read_skip(payload_size)?;
398 let stream = streamres.unwrap();
399 //println!(" stream {}", str_id);
400 if strmgr.is_ignored_id(str_no as u32) {
401 self.src.read_skip(payload_size)?;
404 //todo skip unwanted packet
405 let keyframe = (flags & KEYFRAME_FLAG) != 0;
407 let result = match self.streams[str_id] {
408 RMStreamType::Video(ref mut vstr) => {
410 let pos = self.src.tell();
411 let b0 = self.src.read_byte()?;
413 0 => { // partial frame
414 let b1 = self.src.read_byte()?;
415 let hdr1 = ((b0 as u16) << 8) | (b1 as u16);
416 let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
417 let packet_num = hdr1 & 0x7F;
418 let (_, frame_size) = read_14or30(self.src)?;
419 let (_, off) = read_14or30(self.src)?;
420 let seq_no = self.src.read_byte()?;
421 //println!(" mode 0 pkt {}/{} off {}/{} seq {}", packet_num, num_pkts, off, frame_size, seq_no);
422 let hdr_skip = (self.src.tell() - pos) as usize;
424 let slice_size = (payload_size - hdr_skip) as usize;
425 self.slice_buf.resize(slice_size, 0);
426 self.src.read_buf(self.slice_buf.as_mut_slice())?;
428 vstr.start_slice(num_pkts, frame_size as usize, self.slice_buf.as_slice());
430 vstr.add_slice(packet_num as usize, self.slice_buf.as_slice());
432 if (packet_num as usize) < num_pkts {
435 //todo: check if full frame is received
436 let (tb_num, tb_den) = stream.get_timebase();
437 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
438 let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
441 1 => { // whole frame
442 let seq_no = self.src.read_byte()?;
443 //println!(" mode 1 seq {}", seq_no);
444 read_video_buf(self.src, stream, ts, keyframe, payload_size - 2)
446 2 => { // last partial frame
447 let b1 = self.src.read_byte()?;
448 let hdr1 = ((b0 as u16) << 8) | (b1 as u16);
449 let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
450 let packet_num = hdr1 & 0x7F;
451 let (_, frame_size) = read_14or30(self.src)?;
452 let (_, tail_size) = read_14or30(self.src)?;
453 let seq_no = self.src.read_byte()?;
454 //println!(" mode 2 pkt {}/{} tail {}/{} seq {}", packet_num, num_pkts, tail_size, frame_size, seq_no);
455 self.slice_buf.resize(tail_size as usize, 0);
456 self.src.read_buf(self.slice_buf.as_mut_slice())?;
457 if packet_num == 1 && frame_size == tail_size {
458 vstr.start_slice(num_pkts, frame_size as usize, self.slice_buf.as_slice());
460 vstr.add_slice(packet_num as usize, self.slice_buf.as_slice());
463 while self.src.tell() < pos + (payload_size as u64) {
464 let res = read_multiple_frame(self.src, stream.clone(), false, false);
465 if res.is_err() { break; }
466 self.queued_pkts.push(res.unwrap());
468 self.queued_pkts.reverse();
469 let (tb_num, tb_den) = stream.get_timebase();
470 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
471 let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
474 _ => { // multiple frames
475 //println!(" mode 3");
476 let res = read_multiple_frame(self.src, stream.clone(), keyframe, true);
477 if res.is_err() { return res; }
478 while self.src.tell() < pos + (payload_size as u64) {
479 let res = read_multiple_frame(self.src, stream.clone(), false, false);
480 if res.is_err() { break; }
481 self.queued_pkts.push(res.unwrap());
483 self.queued_pkts.reverse();
488 RMStreamType::Audio(ref mut astr) => {
489 let ret = astr.read_apackets(&mut self.queued_pkts, &mut self.src, stream, ts, keyframe, payload_size);
490 if let Err(DemuxerError::TryAgain) = ret {
496 // self.src.read_skip(payload_size)?;
497 Err(DemuxerError::InvalidData)
504 #[allow(unused_variables)]
505 fn seek(&mut self, time: u64) -> DemuxerResult<()> {
510 fn read_chunk(src: &mut ByteReader) -> DemuxerResult<(u32, u32, u16)> {
511 let id = src.read_u32be()?;
512 if id == 0 { return Ok((0, 0, 0)); }
513 let size = src.read_u32be()?;
515 let ver = src.read_u16be()?;
517 return Ok((id, 0x0FFFFFFF, ver));
519 validate!(size >= 10);
520 let ver = src.read_u16be()?;
525 #[derive(Clone,Copy,Debug)]
526 struct InterleaveInfo {
533 #[derive(Clone,Copy,Debug)]
534 struct RealAudioInfo {
542 bytes_per_minute: u32,
545 ileave_info: Option<InterleaveInfo>
548 fn skip_ra_metadata(src: &mut ByteReader) -> DemuxerResult<()> {
549 let title_len = src.read_byte()? as usize;
550 src.read_skip(title_len)?;
551 let author_len = src.read_byte()? as usize;
552 src.read_skip(author_len)?;
553 let copywrong_len = src.read_byte()? as usize;
554 src.read_skip(copywrong_len)?;
555 let comment_len = src.read_byte()? as usize;
556 src.read_skip(comment_len)?;
560 #[allow(unused_variables)]
561 fn parse_aformat3(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
562 let start = src.tell();
563 let header_len = src.read_u16be()?;
564 validate!(header_len >= 24);
565 let flavor = src.read_u16be()?;
566 let granularity = src.read_u32be()?;
567 let bytes_per_minute = src.read_u32be()?;
568 let total_bytes = src.read_u32be()?;
570 skip_ra_metadata(src)?;
572 let _can_copy = src.read_byte()?;
573 let fcc_len = src.read_byte()?;
574 validate!(fcc_len == 4);
575 let fcc = src.read_u32be()?;
577 let end = src.tell();
578 validate!(end - start <= (header_len as u64) + 2);
581 fcc: fcc, flavor: flavor,
582 sample_rate: 8000, sample_size: 16, channels: 1, channel_mask: 0,
583 granularity: granularity, bytes_per_minute: bytes_per_minute,
584 total_bytes: total_bytes, edata_size: 0,
589 #[allow(unused_variables)]
590 fn parse_aformat4(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
591 let start = src.tell();
592 src.read_skip(2)?; // zeroes
593 let id = src.read_u32be()?;
594 validate!(id == mktag!(b".ra4"));
595 let data_size = src.read_u32be()?;
596 let _ver4 = src.read_u16be()?; // should be 4
597 let header_size = src.read_u32be()?;
598 let flavor = src.read_u16be()?;
599 let granularity = src.read_u32be()?;
600 let total_bytes = src.read_u32be()?;
601 let bytes_per_minute = src.read_u32be()?;
602 let _bytes_per_minute2 = src.read_u32be()?;
603 let ileave_factor = src.read_u16be()?;
604 let ileave_block_size = src.read_u16be()?;
605 let _user_data = src.read_u16be()?;
606 let sample_rate = src.read_u32be()?;
607 let sample_size = src.read_u32be()?;
608 let channels = src.read_u16be()?;
609 let interleaver_id_len = src.read_byte()?;
610 validate!(interleaver_id_len == 4);
611 let interleaver_id = src.read_u32be()?;
612 let fcc_len = src.read_byte()?;
613 validate!(fcc_len == 4);
614 let fcc = src.read_u32be()?;
615 let is_interleaved = src.read_byte()?;
616 let _can_copy = src.read_byte()?;
617 let _stream_type = src.read_byte()?;
619 skip_ra_metadata(src)?;
621 let end = src.tell();
622 validate!(end - start <= (header_size as u64) + 10);
624 let ileave_info = if is_interleaved != 0 {
625 Some(InterleaveInfo {
626 id: interleaver_id, factor: ileave_factor, block_size: granularity as u16,
627 frame_size: ileave_block_size,
634 fcc: fcc, flavor: flavor,
635 sample_rate: sample_rate, sample_size: sample_size as u16, channels: channels, channel_mask: 0,
636 granularity: granularity, bytes_per_minute: bytes_per_minute,
637 total_bytes: total_bytes & 0xFFFFFF, edata_size: 0,
638 ileave_info: ileave_info,
642 #[allow(unused_variables)]
643 fn parse_aformat5(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
644 let start = src.tell();
645 src.read_skip(2)?; // zeroes
646 let id = src.read_u32be()?;
647 validate!((id == mktag!(b".ra5")) || (id == mktag!(b".ra4")));
648 let data_size = src.read_u32be()?;
649 let _ver5 = src.read_u16be()?; // should be 5
650 let header_size = src.read_u32be()?;
651 let flavor = src.read_u16be()?;
652 let granularity = src.read_u32be()?;
653 let total_bytes = src.read_u32be()?;
654 let bytes_per_minute = src.read_u32be()?;
655 let _bytes_per_minute2 = src.read_u32be()?;
656 let ileave_factor = src.read_u16be()?;
657 let frame_size = src.read_u16be()?;
658 let ileave_block_size = src.read_u16be()?;
659 let user_data = src.read_u32be()?;
660 let _sample_rate1 = src.read_u16be()?;
661 let sample_rate = src.read_u32be()?;
662 let sample_size = src.read_u32be()?;
663 let channels = src.read_u16be()?;
664 let interleaver_id = src.read_u32be()?;
665 let fcc = src.read_u32be()?;
666 let is_interleaved = src.read_byte()?;
667 let _can_copy = src.read_byte()?;
668 let _stream_type = src.read_byte()?;
669 let has_ileave_pattern = src.read_byte()?;
670 if has_ileave_pattern != 0 {
671 unimplemented!("ra5 interleave pattern");
673 let mut edata_size = src.read_u32be()?;
674 let end = src.tell();
675 if id == mktag!(b".ra5") {
676 validate!(end - start <= (header_size as u64) + 10);
677 // src.read_skip(((end - start) as usize) - (header_size as usize) - 10)?;
679 validate!(end - start <= (header_size as u64) + 15);
682 let ileave_info = if is_interleaved != 0 {
683 Some(InterleaveInfo {
684 id: interleaver_id, factor: ileave_factor, block_size: ileave_block_size, frame_size: frame_size,
689 if (fcc == mktag!(b"raac")) || (fcc == mktag!(b"racp")) {
690 validate!(edata_size > 1);
696 fcc: fcc, flavor: flavor,
697 sample_rate: sample_rate, sample_size: sample_size as u16, channels: channels, channel_mask: 0,
698 granularity: granularity, bytes_per_minute: bytes_per_minute,
699 total_bytes: total_bytes & 0xFFFFFF, edata_size: edata_size,
700 ileave_info: ileave_info,
704 const RMVB_HDR_SIZE: u32 = 18;
705 const RMVB_PROP_SIZE: u32 = 50;
706 const KEYFRAME_FLAG: u8 = 0x02;
708 impl<'a> RealMediaDemuxer<'a> {
709 fn new(io: &'a mut ByteReader<'a>) -> Self {
719 queued_pkts: Vec::new(),
720 slice_buf: Vec::new(),
723 #[allow(unused_variables)]
724 fn read_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
725 let (id, size, ver) = read_chunk(self.src)?;
726 validate!((id == mktag!(b".RMF")) || (id == mktag!(b".RMP")));
727 validate!(size >= RMVB_HDR_SIZE);
728 let fver = self.src.read_u32be()?;
729 validate!(fver <= 1);
730 let num_hdr = self.src.read_u32be()? as usize;
731 validate!(num_hdr >= 1);
732 if size > RMVB_HDR_SIZE {
733 self.src.read_skip((size - RMVB_HDR_SIZE) as usize)?;
736 let (id, size, ver) = read_chunk(self.src)?;
737 let prop_size = if ver == 0 { RMVB_PROP_SIZE } else { RMVB_PROP_SIZE + 4 };
738 validate!(size >= prop_size);
739 validate!((ver == 0) || (ver == 2));
740 let maxbr = self.src.read_u32be()?;
741 let avgbr = self.src.read_u32be()?;
742 let maxps = self.src.read_u32be()?;
743 let avgps = self.src.read_u32be()?;
744 let num_pkt = self.src.read_u32be()? as usize;
745 let duration = self.src.read_u32be()?;
746 let preroll = self.src.read_u32be()?;
748 self.src.read_skip(4)?;
750 let idx_off = self.src.read_u32be()?;
751 let data_off = self.src.read_u32be()?;
752 let num_streams = self.src.read_u16be()? as usize;
753 let flags = self.src.read_u16be()?;
754 if size > prop_size {
755 self.src.read_skip((size - prop_size) as usize)?;
758 for _ in 0..num_hdr {
759 if self.src.is_eof() {
763 let res = self.parse_chunk(strmgr);
765 Ok(last) => { if last { break; } },
766 Err(DemuxerError::IOError) => { break; },
768 if self.data_pos == 0 { // data is not found, report error
774 //println!("now @ {:X} / {}", self.src.tell(), self.data_pos);
775 validate!(self.data_pos > 0);
776 self.src.seek(SeekFrom::Start(self.data_pos))?;
777 self.parse_data_start()?;
780 fn parse_data_start(&mut self) -> DemuxerResult<()> {
781 let num_packets = self.src.read_u32be()?;
782 if self.data_ver == 2 {
783 self.src.read_skip(12)?; // zeroes?
785 let next_data_hdr = self.src.read_u32be()?;
786 self.num_packets = if num_packets > 0 { num_packets } else { 0xFFFFFF };
788 self.next_data = next_data_hdr as u64;
791 fn parse_chunk(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<bool> {
792 let (id, size, ver) = read_chunk(self.src)?;
793 let end_pos = self.src.tell() - 10 + (size as u64);
795 validate!((ver == 0) || (ver == 2));
796 if id == mktag!(b"CONT") { self.parse_content_desc()?; }
797 else if id == mktag!(b"MDPR") { self.parse_mdpr(strmgr)?; }
798 else if id == mktag!(b"DATA") { if self.data_pos == 0 { self.data_ver = ver; self.data_pos = self.src.tell(); } }
799 else if id == mktag!(b"INDX") { /* do nothing for now */ }
800 else if id == 0 { return Ok(true); }
801 else { println!("unknown chunk type {:08X}", id); }
803 let cpos = self.src.tell();
805 self.src.read_skip((end_pos - cpos) as usize)?;
809 #[allow(unused_variables)]
810 fn parse_content_desc(&mut self) -> DemuxerResult<()> {
811 let title_len = self.src.read_u16be()? as usize;
812 self.src.read_skip(title_len)?;
813 let author_len = self.src.read_u16be()? as usize;
814 self.src.read_skip(author_len)?;
815 let copywrong_len = self.src.read_u16be()? as usize;
816 self.src.read_skip(copywrong_len)?;
817 let comment_len = self.src.read_u16be()? as usize;
818 self.src.read_skip(comment_len)?;
821 #[allow(unused_variables)]
822 fn parse_mdpr(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
823 let stream_no = self.src.read_u16be()?;
824 //todo check stream_no for duplicates
825 let maxbr = self.src.read_u32be()?;
826 let avgbr = self.src.read_u32be()?;
827 let maxps = self.src.read_u32be()?;
828 let avgps = self.src.read_u32be()?;
829 let start = self.src.read_u32be()?;
830 let preroll = self.src.read_u32be()?;
831 let duration = self.src.read_u32be()?;
832 let sname_size = self.src.read_byte()? as usize;
833 let sname = read_string_size(self.src, sname_size)?;
834 //println!("str #{} sname = {} pkts {}/{} start {} preroll {}", stream_no, sname, maxps, avgps, start, preroll);
835 let mime_size = self.src.read_byte()? as usize;
836 let mime = read_string_size(self.src, mime_size)?;
837 //println!("mime = {}", mime);
838 let edata_size = self.src.read_u32be()? as usize;
839 let edata: Option<Vec<u8>> = if edata_size == 0 { None } else {
840 let mut edvec: Vec<u8> = Vec::with_capacity(edata_size);
841 edvec.resize(edata_size, 0);
842 self.src.read_buf(&mut edvec)?;
845 self.str_ids.push(stream_no);
847 if let Some(edata_) = edata {
848 let mut mr = MemoryReader::new_read(edata_.as_slice());
849 let mut src = ByteReader::new(&mut mr);
851 let tag = src.read_u32be()?;
852 let tag2 = src.peek_u32be()?;
853 //println!("tag1 {:X} tag2 {:X}", tag, tag2);
854 if tag == mktag!('.', 'r', 'a', 0xFD) {
855 let ver = src.read_u16be()?;
856 let ainfo = match ver {
858 parse_aformat3(&mut src)?
861 parse_aformat4(&mut src)?
864 parse_aformat5(&mut src)?
867 println!("unknown version {}", ver);
868 return Err(DemuxerError::InvalidData);
871 println!(" got ainfo {:?}", ainfo);
872 let cname = find_codec_name(RM_AUDIO_CODEC_REGISTER, ainfo.fcc);
873 let blk_size = if ainfo.fcc != mktag!(b"sipr") {
874 ainfo.granularity as usize
876 validate!(ainfo.flavor <= 3);
877 RM_SIPRO_BLOCK_SIZES[ainfo.flavor as usize]
879 let srate = ainfo.sample_rate;
880 let soniton = NASoniton::new(ainfo.sample_size as u8, SONITON_FLAG_SIGNED);
881 let ahdr = NAAudioInfo::new(srate, ainfo.channels as u8, soniton, blk_size);
882 let extradata = if ainfo.edata_size == 0 {
885 let eslice = &edata_[(src.tell() as usize)..];
886 Some(eslice.to_vec())
888 let nainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
889 let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, srate));
890 if res.is_none() { return Err(MemoryError); }
892 let astr = RMAudioStream::new(ainfo.ileave_info);
893 self.streams.push(RMStreamType::Audio(astr));
894 } else if ((tag2 == mktag!('V', 'I', 'D', 'O')) || (tag2 == mktag!('I', 'M', 'A', 'G'))) && ((tag as usize) <= edata_size) {
896 let fcc = src.read_u32be()?;
897 let width = src.read_u16be()? as usize;
898 let height = src.read_u16be()? as usize;
899 let bpp = src.read_u16be()?;
900 let pad_w = src.read_u16be()?;
901 let pad_h = src.read_u16be()?;
903 if tag2 == mktag!('V', 'I', 'D', 'O') {
904 fps = src.read_u32be()?;
908 let extradata: Option<Vec<u8>>;
910 let eslice = &edata_[(src.tell() as usize)..];
911 extradata = Some(eslice.to_vec());
915 let cname = find_codec_name(RM_VIDEO_CODEC_REGISTER, fcc);
917 let vhdr = NAVideoInfo::new(width, height, false, RGB24_FORMAT);
918 let vinfo = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), extradata);
919 let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no as u32, vinfo, 0x10000, fps));
920 if res.is_none() { return Err(DemuxerError::MemoryError); }
922 let vstr = RMVideoStream::new();
923 self.streams.push(RMStreamType::Video(vstr));
924 } else if tag == mktag!(b"LSD:") {
925 let extradata = Some(edata_.to_vec());
927 src.read_skip(4)?; //version
928 let channels = src.read_u16be()?;
929 let samp_size = src.read_u16be()?;
930 let sample_rate = src.read_u32be()?;
932 println!("LSD sr {}, {} ch", sample_rate, channels);
933 let soniton = NASoniton::new(samp_size as u8, SONITON_FLAG_SIGNED);
934 let ahdr = NAAudioInfo::new(sample_rate, channels as u8, soniton, 1);
935 let nainfo = NACodecInfo::new("ralf", NACodecTypeInfo::Audio(ahdr), extradata);
936 let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, sample_rate));
937 if res.is_none() { return Err(MemoryError); }
938 let astr = RMAudioStream::new(None);
939 self.streams.push(RMStreamType::Audio(astr));
941 self.streams.push(RMStreamType::Logical);
945 self.streams.push(RMStreamType::Unknown);
950 /*#[allow(unused_variables)]
951 fn read_pkt_header(&mut self) -> DemuxerResult<()> {
952 let ver = self.src.read_u16be()?;
954 let str_no = self.src.read_u16be()?;
955 let timestamp = self.src.read_u32be()?;
957 let pkt_group = self.src.read_byte()?;
958 let pkt_flags = self.src.read_byte()?;
960 let asm_rule = self.src.read_u16be()?;
961 let asm_flags = self.src.read_byte()?;
967 fn read_string(src: &mut ByteReader) -> DemuxerResult<String> {
968 let mut vec: Vec<u8> = Vec::new();
970 let c = src.read_byte()?;
974 let str = String::from_utf8(vec);
982 fn read_string_size(src: &mut ByteReader, size: usize) -> DemuxerResult<String> {
983 let mut vec: Vec<u8> = Vec::new();
985 let c = src.read_byte()?;
988 let str = String::from_utf8(vec);
997 #[allow(unused_variables)]
998 fn parse_rm_stream(io: &mut ByteReader) -> DemuxerResult<NAStream> {
999 let mimetype = read_string(io)?;
1000 let strname = read_string(io)?;
1001 let strnum = io.read_u32be()?;
1002 let maxbr = io.read_u32be()?;
1003 let avgbr = io.read_u32be()?;
1004 let maxsize = io.read_u32be()?;
1005 let avgsize = io.read_u32be()?;
1006 let duration = io.read_u32be()?;
1007 let preroll = io.read_u32be()?;
1008 let start = io.read_u32be()?;
1009 let edatalen = io.read_u32be()? as usize;
1010 let mut edata: Vec<u8> = Vec::with_capacity(edatalen);
1011 edata.resize(edatalen, 0);
1012 io.read_buf(&mut edata)?;
1013 let numprops = io.read_u32be()? as usize;
1018 struct RealAudioDemuxer<'a> {
1019 src: &'a mut ByteReader<'a>,
1020 stream: Option<RMAudioStream>,
1024 queued_pkts: Vec<NAPacket>,
1027 impl<'a> DemuxCore<'a> for RealAudioDemuxer<'a> {
1028 #[allow(unused_variables)]
1029 fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
1030 let magic = self.src.read_u32be()?;
1031 validate!(magic == mktag!(b".ra\xFD"));
1032 let ver = self.src.read_u16be()?;
1033 let ainfo = match ver {
1035 parse_aformat3(&mut self.src)?
1038 parse_aformat4(&mut self.src)?
1041 parse_aformat5(&mut self.src)?
1044 println!("unknown version {}", ver);
1045 return Err(DemuxerError::InvalidData);
1048 println!(" got ainfo {:?}", ainfo);
1049 let cname = find_codec_name(RM_AUDIO_CODEC_REGISTER, ainfo.fcc);
1050 let blk_size = if ainfo.fcc != mktag!(b"sipr") {
1051 ainfo.granularity as usize
1053 validate!(ainfo.flavor <= 3);
1054 RM_SIPRO_BLOCK_SIZES[ainfo.flavor as usize]
1056 let srate = ainfo.sample_rate;
1057 let soniton = NASoniton::new(ainfo.sample_size as u8, SONITON_FLAG_SIGNED);
1058 let ahdr = NAAudioInfo::new(srate, ainfo.channels as u8, soniton, blk_size);
1059 let extradata = if ainfo.edata_size == 0 {
1062 let mut dta: Vec<u8> = Vec::with_capacity(ainfo.edata_size as usize);
1063 dta.resize(ainfo.edata_size as usize, 0);
1064 self.src.read_buf(dta.as_mut_slice())?;
1067 let nainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
1068 let res = strmgr.add_stream(NAStream::new(StreamType::Audio, 0, nainfo, 1, srate));
1069 if res.is_none() { return Err(MemoryError); }
1071 let astr = RMAudioStream::new(ainfo.ileave_info);
1072 self.data_start = self.src.tell();
1073 self.data_end = if ainfo.total_bytes > 0 { self.src.tell() + (ainfo.total_bytes as u64) } else { 0 };
1074 self.blk_size = blk_size;
1075 self.stream = Some(astr);
1080 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
1081 if !self.queued_pkts.is_empty() {
1082 let pkt = self.queued_pkts.pop().unwrap();
1085 if (self.data_end != 0) && (self.src.tell() >= self.data_end) {
1086 return Err(DemuxerError::EOF);
1088 let streamres = strmgr.get_stream_by_id(0);
1089 let stream = streamres.unwrap();
1090 if let Some(ref mut astr) = self.stream {
1092 let ret = astr.read_apackets(&mut self.queued_pkts, &mut self.src, stream.clone(), 0, false, self.blk_size);
1093 if let Err(DemuxerError::TryAgain) = ret {
1099 Err(DemuxerError::NoSuchInput)
1102 #[allow(unused_variables)]
1103 fn seek(&mut self, time: u64) -> DemuxerResult<()> {
1108 impl<'a> RealAudioDemuxer<'a> {
1109 fn new(io: &'a mut ByteReader<'a>) -> Self {
1116 queued_pkts: Vec::new(),
1121 static RM_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
1122 (b"RV10", "realvideo1"),
1123 (b"RV20", "realvideo2"),
1124 (b"RVTR", "realvideo2"),
1125 (b"RV30", "realvideo3"),
1126 (b"RV40", "realvideo4"),
1127 (b"RV60", "realvideo6"),
1128 (b"CLV1", "clearvideo_rm"),
1132 static RM_AUDIO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
1133 (b"lpcJ", "ra14.4"),
1134 (b"28_8", "ra28.8"),
1138 (b"atrc", "atrac3"),
1144 pub struct RealMediaDemuxerCreator { }
1146 impl DemuxerCreator for RealMediaDemuxerCreator {
1147 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
1148 Box::new(RealMediaDemuxer::new(br))
1150 fn get_name(&self) -> &'static str { "realmedia" }
1153 pub struct RealAudioDemuxerCreator { }
1155 impl DemuxerCreator for RealAudioDemuxerCreator {
1156 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
1157 Box::new(RealAudioDemuxer::new(br))
1159 fn get_name(&self) -> &'static str { "realaudio" }
1162 /*pub struct RealIVRDemuxerCreator { }
1164 impl DemuxerCreator for RealIVRDemuxerCreator {
1165 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
1166 Box::new(RealIVRDemuxer::new(br))
1168 fn get_name(&self) -> &'static str { "real_ivr" }
1177 fn test_rm_demux() {
1179 File::open("assets/RV/rv10_dnet_640x352_realvideo_encoder_4.0.rm").unwrap();
1180 // File::open("assets/RV/rv20_cook_640x352_realproducer_plus_8.51.rm").unwrap();
1181 // File::open("assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm").unwrap();
1182 // File::open("assets/RV/rv30_atrc_384x208_realproducer_plus_8.51.rm").unwrap();
1183 // File::open("assets/RV/rv30_chroma_drift.rm").unwrap();
1184 // File::open("assets/RV/rv30_weighted_mc.rm").unwrap();
1185 // File::open("assets/RV/rv40_weighted_mc.rmvb").unwrap();
1186 // File::open("assets/RV/rv40_weighted_mc_2.rmvb").unwrap();
1187 // File::open("assets/RV/clv1_sipr_384x208_realvideo_encoder_4.0.rm").unwrap();
1188 // File::open("assets/RV/luckynight.rmvb").unwrap();
1189 // File::open("assets/RV/rv40_ralf.rmvb").unwrap();
1190 let mut fr = FileReader::new_read(&mut file);
1191 let mut br = ByteReader::new(&mut fr);
1192 let mut dmx = RealMediaDemuxer::new(&mut br);
1193 let mut sm = StreamManager::new();
1194 dmx.open(&mut sm).unwrap();
1197 let pktres = dmx.get_frame(&mut sm);
1198 if let Err(e) = pktres {
1199 if e == DemuxerError::EOF { break; }
1202 let pkt = pktres.unwrap();
1203 println!("Got {}", pkt);
1205 //panic!("the end");
1208 fn test_ra_demux() {
1210 // File::open("assets/RV/welcome288.ra").unwrap();
1211 File::open("assets/RV/diemusik.ra").unwrap();
1212 let mut fr = FileReader::new_read(&mut file);
1213 let mut br = ByteReader::new(&mut fr);
1214 let mut dmx = RealAudioDemuxer::new(&mut br);
1215 let mut sm = StreamManager::new();
1216 dmx.open(&mut sm).unwrap();
1219 let pktres = dmx.get_frame(&mut sm);
1220 if let Err(e) = pktres {
1221 if e == DemuxerError::EOF { break; }
1224 let pkt = pktres.unwrap();
1225 println!("Got {}", pkt);