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 struct RMVideoStream {
35 self.frame.truncate(0);
39 fn start_slice(&mut self, num_slices: usize, frame_size: usize, data: &[u8]) {
40 self.hdr_size = num_slices * 8 + 1;
41 self.frame.resize(frame_size + self.hdr_size, 0);
42 self.frame[0] = (num_slices - 1) as u8;
44 self.add_slice(1, data);
46 fn add_slice(&mut self, slice_no: usize, data: &[u8]) {
47 self.write_slice_info(slice_no);
48 let dslice = &mut self.frame[self.hdr_size + self.frame_pos..][..data.len()];
49 dslice.copy_from_slice(data);
50 self.frame_pos += data.len();
52 fn write_slice_info(&mut self, slice_no: usize) {
53 let off = 1 + (slice_no - 1) * 8;
54 self.frame[off + 0] = 0;
55 self.frame[off + 1] = 0;
56 self.frame[off + 2] = 0;
57 self.frame[off + 3] = 1;
58 self.frame[off + 4] = (self.frame_pos >> 24) as u8;
59 self.frame[off + 5] = (self.frame_pos >> 16) as u8;
60 self.frame[off + 6] = (self.frame_pos >> 8) as u8;
61 self.frame[off + 7] = (self.frame_pos >> 0) as u8;
63 fn get_frame_data(&mut self) -> Vec<u8> {
64 let mut v: Vec<u8> = Vec::new();
65 mem::swap(&mut v, &mut self.frame);
72 #[derive(Clone,Copy,PartialEq)]
82 struct RMAudioStream {
84 iinfo: Option<InterleaveInfo>,
89 const RM_ILEAVE_INT0: u32 = mktag!(b"Int0");
90 const RM_ILEAVE_INT4: u32 = mktag!(b"Int4");
91 const RM_ILEAVE_GENR: u32 = mktag!(b"genr");
92 const RM_ILEAVE_SIPR: u32 = mktag!(b"sipr");
93 const RM_ILEAVE_VBRS: u32 = mktag!(b"vbrs");
96 fn new(iinfo: Option<InterleaveInfo>) -> Self {
99 if let Some(info) = iinfo {
100 deint = match info.id {
101 RM_ILEAVE_INT0 => Deinterleaver::None,
102 RM_ILEAVE_INT4 => Deinterleaver::RA28_8,
103 RM_ILEAVE_GENR => Deinterleaver::Generic,
104 RM_ILEAVE_SIPR => Deinterleaver::Sipro,
105 RM_ILEAVE_VBRS => Deinterleaver::VBR,
106 _ => {println!("unknown deint {:X}", info.id); Deinterleaver::None },
109 Deinterleaver::None => { buf = Vec::new(); },
110 Deinterleaver::RA28_8 => {
111 let bsize = (info.frame_size as usize) * (info.factor as usize);
112 buf = Vec::with_capacity(bsize);
113 buf.resize(bsize, 0u8);
115 Deinterleaver::Generic => { unimplemented!("deint"); },
116 Deinterleaver::Sipro => { unimplemented!("deint"); },
117 Deinterleaver::VBR => { unimplemented!("deint"); },
120 deint = Deinterleaver::None;
123 RMAudioStream { deint: deint, iinfo: iinfo, buf: buf, sub_packet: 0 }
125 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> {
126 let (tb_num, tb_den) = stream.get_timebase();
127 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
133 Deinterleaver::None => { src.read_packet(stream, ts, keyframe, payload_size) },
134 Deinterleaver::RA28_8 => {
135 let iinfo = self.iinfo.unwrap();
136 let factor = iinfo.factor as usize;
137 let halffact = factor >> 1;
138 let fsize = iinfo.frame_size as usize;
139 let bsize = iinfo.block_size as usize;
140 let ppos = self.sub_packet;
141 for sb in 0..halffact {
142 let mut dst = &mut self.buf[sb * 2 * fsize + ppos * bsize..][..bsize];
143 src.read_buf(&mut dst)?;
145 self.sub_packet += 1;
146 if self.sub_packet == factor {
148 Ok(NAPacket::new(stream, ts, true, self.buf.clone()))
150 Err(DemuxerError::TryAgain)
153 _ => { src.read_packet(stream, ts, keyframe, payload_size) },
159 Audio(RMAudioStream),
160 Video(RMVideoStream),
165 struct RealMediaDemuxer<'a> {
166 src: &'a mut ByteReader<'a>,
171 streams: Vec<RMStreamType>,
174 queued_pkts: Vec<NAPacket>,
178 fn find_codec_name(registry: &[(&[u8;4], &'static str)], fcc: u32) -> &'static str {
179 for &(fourcc, name) in registry {
180 if mktag!(fourcc) == fcc { return name; }
185 fn read_14or30(src: &mut ByteReader) -> DemuxerResult<(bool, u32)> {
186 let tmp = src.read_u16be()?;
187 let flag = (tmp & 0x8000) != 0;
188 if (tmp & 0x4000) == 0x4000 {
189 Ok((flag, ((tmp & 0x3FFF) as u32)))
191 let val = ((tmp as u32) << 16) | (src.read_u16be()? as u32);
192 Ok((flag, val & 0x3FFFFFFF))
196 fn read_video_buf(src: &mut ByteReader, stream: Rc<NAStream>, ts: u32, keyframe: bool, frame_size: usize) -> DemuxerResult<NAPacket> {
197 let size = (frame_size as usize) + 9;
198 let mut vec: Vec<u8> = Vec::with_capacity(size);
200 //v[0] = 0; // 1 slice
202 src.read_buf(&mut vec[9..])?;
204 let (tb_num, tb_den) = stream.get_timebase();
205 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
206 Ok(NAPacket::new(stream, ts, keyframe, vec))
209 fn read_multiple_frame(src: &mut ByteReader, stream: Rc<NAStream>, keyframe: bool, skip_mtype: bool) -> DemuxerResult<NAPacket> {
211 let mtype = src.read_byte()?;
212 validate!(mtype == 0xC0);
214 let (_, frame_size) = read_14or30(src)?;
215 let (_, timestamp) = read_14or30(src)?;
216 let _seq_no = src.read_byte()?;
217 //println!(" multiple frame size {} ts {} seq {}", frame_size, timestamp, seq_no);
219 read_video_buf(src, stream, timestamp, keyframe, frame_size as usize)
222 impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> {
223 #[allow(unused_variables)]
224 fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
225 self.read_header(strmgr)?;
229 #[allow(unused_variables)]
230 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
231 if !self.queued_pkts.is_empty() {
232 let pkt = self.queued_pkts.pop().unwrap();
236 if self.cur_packet >= self.num_packets { return Err(DemuxerError::EOF); }
238 let pkt_start = self.src.tell();
239 let ver = self.src.read_u16le()?;
241 let len = self.src.read_u16be()? as usize;
242 let str_no = self.src.read_u16be()?;
243 let ts = self.src.read_u32be()?;
246 _pkt_grp = self.src.read_byte()?;
248 //asm_rule = self.src.read_u16le()?;
249 self.src.read_skip(2)?;
252 let flags = self.src.read_byte()?;
253 let hdr_size = self.src.tell() - pkt_start;
254 //println!("packet @{:X} size {} for {} ts {} grp {} flags {:X}", pkt_start, len, str_no, ts, pkt_grp, flags);
255 self.cur_packet += 1;
257 let payload_size = len - (hdr_size as usize);
259 let sr = self.str_ids.iter().position(|x| *x == str_no);
261 //println!("stream {} not found", str_no);
262 self.src.read_skip(payload_size)?;
263 return Err(DemuxerError::InvalidData);
265 let str_id = sr.unwrap();
266 let streamres = strmgr.get_stream_by_id(str_no as u32);
267 if streamres.is_none() {
268 self.src.read_skip(payload_size)?;
271 let stream = streamres.unwrap();
272 //println!(" stream {}", str_id);
273 if strmgr.is_ignored_id(str_no as u32) {
274 self.src.read_skip(payload_size)?;
277 //todo skip unwanted packet
278 let keyframe = (flags & KEYFRAME_FLAG) != 0;
280 let result = match self.streams[str_id] {
281 RMStreamType::Video(ref mut vstr) => {
283 let pos = self.src.tell();
284 let b0 = self.src.read_byte()?;
286 0 => { // partial frame
287 let b1 = self.src.read_byte()?;
288 let hdr1 = ((b0 as u16) << 8) | (b1 as u16);
289 let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
290 let packet_num = hdr1 & 0x7F;
291 let (_, frame_size) = read_14or30(self.src)?;
292 let (_, off) = read_14or30(self.src)?;
293 let seq_no = self.src.read_byte()?;
294 //println!(" mode 0 pkt {}/{} off {}/{} seq {}", packet_num, num_pkts, off, frame_size, seq_no);
295 let hdr_skip = (self.src.tell() - pos) as usize;
297 let slice_size = (payload_size - hdr_skip) as usize;
298 self.slice_buf.resize(slice_size, 0);
299 self.src.read_buf(self.slice_buf.as_mut_slice())?;
301 vstr.start_slice(num_pkts, frame_size as usize, self.slice_buf.as_slice());
303 vstr.add_slice(packet_num as usize, self.slice_buf.as_slice());
305 if (packet_num as usize) < num_pkts {
308 //todo: check if full frame is received
309 let (tb_num, tb_den) = stream.get_timebase();
310 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
311 let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
314 1 => { // whole frame
315 let seq_no = self.src.read_byte()?;
316 //println!(" mode 1 seq {}", seq_no);
317 read_video_buf(self.src, stream, ts, keyframe, payload_size - 1)
319 2 => { // last partial frame
320 let b1 = self.src.read_byte()?;
321 let hdr1 = ((b0 as u16) << 8) | (b1 as u16);
322 let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
323 let packet_num = hdr1 & 0x7F;
324 let (_, frame_size) = read_14or30(self.src)?;
325 let (_, tail_size) = read_14or30(self.src)?;
326 let seq_no = self.src.read_byte()?;
327 //println!(" mode 2 pkt {}/{} tail {}/{} seq {}", packet_num, num_pkts, tail_size, frame_size, seq_no);
328 self.slice_buf.resize(tail_size as usize, 0);
329 self.src.read_buf(self.slice_buf.as_mut_slice())?;
330 vstr.add_slice(packet_num as usize, self.slice_buf.as_slice());
332 while self.src.tell() < pos + (payload_size as u64) {
333 let res = read_multiple_frame(self.src, stream.clone(), false, false);
334 if res.is_err() { break; }
335 self.queued_pkts.push(res.unwrap());
337 self.queued_pkts.reverse();
338 let (tb_num, tb_den) = stream.get_timebase();
339 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
340 let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
343 _ => { // multiple frames
344 //println!(" mode 3");
345 let res = read_multiple_frame(self.src, stream.clone(), keyframe, true);
346 if res.is_err() { return res; }
347 while self.src.tell() < pos + (payload_size as u64) {
348 let res = read_multiple_frame(self.src, stream.clone(), false, false);
349 if res.is_err() { break; }
350 self.queued_pkts.push(res.unwrap());
352 self.queued_pkts.reverse();
357 RMStreamType::Audio(ref mut astr) => {
358 let ret = astr.read_apackets(&mut self.queued_pkts, &mut self.src, stream, ts, keyframe, payload_size);
359 if let Err(DemuxerError::TryAgain) = ret {
365 // self.src.read_skip(payload_size)?;
366 Err(DemuxerError::InvalidData)
373 #[allow(unused_variables)]
374 fn seek(&mut self, time: u64) -> DemuxerResult<()> {
379 fn read_chunk(src: &mut ByteReader) -> DemuxerResult<(u32, u32, u16)> {
380 let id = src.read_u32be()?;
381 if id == 0 { return Ok((0, 0, 0)); }
382 let size = src.read_u32be()?;
383 validate!(size >= 10);
384 let ver = src.read_u16be()?;
389 #[derive(Clone,Copy,Debug)]
390 struct InterleaveInfo {
397 #[derive(Clone,Copy,Debug)]
398 struct RealAudioInfo {
405 bytes_per_minute: u32,
408 ileave_info: Option<InterleaveInfo>
411 fn skip_ra_metadata(src: &mut ByteReader) -> DemuxerResult<()> {
412 let title_len = src.read_byte()? as usize;
413 src.read_skip(title_len)?;
414 let author_len = src.read_byte()? as usize;
415 src.read_skip(author_len)?;
416 let copywrong_len = src.read_byte()? as usize;
417 src.read_skip(copywrong_len)?;
418 let comment_len = src.read_byte()? as usize;
419 src.read_skip(comment_len)?;
423 #[allow(unused_variables)]
424 fn parse_aformat3(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
425 let start = src.tell();
426 let header_len = src.read_u16be()?;
427 validate!(header_len >= 24);
428 let flavor = src.read_u16be()?;
429 let granularity = src.read_u32be()?;
430 let bytes_per_minute = src.read_u32be()?;
431 let total_bytes = src.read_u32be()?;
433 skip_ra_metadata(src)?;
435 let _can_copy = src.read_byte()?;
436 let fcc_len = src.read_byte()?;
437 validate!(fcc_len == 4);
438 let fcc = src.read_u32be()?;
440 let end = src.tell();
441 validate!(end - start <= (header_len as u64) + 2);
444 fcc: fcc, sample_rate: 8000, sample_size: 16, channels: 1, channel_mask: 0,
445 granularity: granularity, bytes_per_minute: bytes_per_minute,
446 total_bytes: total_bytes, edata_size: 0,
451 #[allow(unused_variables)]
452 fn parse_aformat4(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
453 let start = src.tell();
454 src.read_skip(2)?; // zeroes
455 let id = src.read_u32be()?;
456 validate!(id == mktag!(b".ra4"));
457 let data_size = src.read_u32be()?;
458 let _ver4 = src.read_u16be()?; // should be 4
459 let header_size = src.read_u32be()?;
460 let _flavor = src.read_u16be()?;
461 let granularity = src.read_u32be()?;
462 let total_bytes = src.read_u32be()?;
463 let bytes_per_minute = src.read_u32be()?;
464 let _bytes_per_minute2 = src.read_u32be()?;
465 let ileave_factor = src.read_u16be()?;
466 let ileave_block_size = src.read_u16be()?;
467 let _user_data = src.read_u16be()?;
468 let sample_rate = src.read_u32be()?;
469 let sample_size = src.read_u32be()?;
470 let channels = src.read_u16be()?;
471 let interleaver_id_len = src.read_byte()?;
472 validate!(interleaver_id_len == 4);
473 let interleaver_id = src.read_u32be()?;
474 let fcc_len = src.read_byte()?;
475 validate!(fcc_len == 4);
476 let fcc = src.read_u32be()?;
477 let is_interleaved = src.read_byte()?;
478 let _can_copy = src.read_byte()?;
479 let _stream_type = src.read_byte()?;
481 skip_ra_metadata(src)?;
483 let end = src.tell();
484 validate!(end - start <= (header_size as u64) + 10);
486 let ileave_info = if is_interleaved != 0 {
487 Some(InterleaveInfo {
488 id: interleaver_id, factor: ileave_factor, block_size: granularity as u16,
489 frame_size: ileave_block_size,
496 fcc: fcc, sample_rate: sample_rate, sample_size: sample_size as u16, channels: channels, channel_mask: 0,
497 granularity: granularity, bytes_per_minute: bytes_per_minute,
498 total_bytes: total_bytes & 0xFFFFFF, edata_size: 0,
499 ileave_info: ileave_info,
503 #[allow(unused_variables)]
504 fn parse_aformat5(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
505 let start = src.tell();
506 src.read_skip(2)?; // zeroes
507 let id = src.read_u32be()?;
508 validate!(id == mktag!(b".ra5"));
509 let data_size = src.read_u32be()?;
510 let _ver5 = src.read_u16be()?; // should be 5
511 let header_size = src.read_u32be()?;
512 let _flavor = src.read_u16be()?;
513 let granularity = src.read_u32be()?;
514 let total_bytes = src.read_u32be()?;
515 let bytes_per_minute = src.read_u32be()?;
516 let _bytes_per_minute2 = src.read_u32be()?;
517 let ileave_factor = src.read_u16be()?;
518 let ileave_block_size = src.read_u16be()?;
519 let frame_size = src.read_u16be()?;
520 let user_data = src.read_u32be()?;
521 let _sample_rate1 = src.read_u16be()?;
522 let sample_rate = src.read_u32be()?;
523 let sample_size = src.read_u32be()?;
524 let channels = src.read_u16be()?;
525 let interleaver_id = src.read_u32be()?;
526 let fcc = src.read_u32be()?;
527 let is_interleaved = src.read_byte()?;
528 let _can_copy = src.read_byte()?;
529 let _stream_type = src.read_byte()?;
530 let has_ileave_pattern = src.read_byte()?;
531 if has_ileave_pattern != 0 {
532 unimplemented!("ra5 interleave pattern");
534 let edata_size = src.read_u32be()?;
536 let end = src.tell();
537 validate!(end - start <= (header_size as u64) + 10);
538 src.read_skip((end as usize) - (header_size as usize))?;
540 let ileave_info = if is_interleaved != 0 {
541 Some(InterleaveInfo {
542 id: interleaver_id, factor: ileave_factor, block_size: ileave_block_size, frame_size: frame_size,
549 fcc: fcc, sample_rate: sample_rate, sample_size: sample_size as u16, channels: channels, channel_mask: 0,
550 granularity: granularity, bytes_per_minute: bytes_per_minute,
551 total_bytes: total_bytes & 0xFFFFFF, edata_size: edata_size,
552 ileave_info: ileave_info,
556 const RMVB_HDR_SIZE: u32 = 18;
557 const RMVB_PROP_SIZE: u32 = 50;
558 const KEYFRAME_FLAG: u8 = 0x02;
560 impl<'a> RealMediaDemuxer<'a> {
561 fn new(io: &'a mut ByteReader<'a>) -> Self {
569 queued_pkts: Vec::new(),
570 slice_buf: Vec::new(),
573 #[allow(unused_variables)]
574 fn read_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
575 let (id, size, ver) = read_chunk(self.src)?;
576 validate!(id == mktag!(b".RMF"));
577 validate!(size >= RMVB_HDR_SIZE);
578 let fver = self.src.read_u32be()?;
579 validate!(fver <= 1);
580 let num_hdr = self.src.read_u32be()? as usize;
581 validate!(num_hdr >= 1);
582 if size > RMVB_HDR_SIZE {
583 self.src.read_skip((size - RMVB_HDR_SIZE) as usize)?;
586 let (id, size, ver) = read_chunk(self.src)?;
587 validate!(size >= RMVB_PROP_SIZE);
589 let maxbr = self.src.read_u32be()?;
590 let avgbr = self.src.read_u32be()?;
591 let maxps = self.src.read_u32be()?;
592 let avgps = self.src.read_u32be()?;
593 let num_pkt = self.src.read_u32be()? as usize;
594 let duration = self.src.read_u32be()?;
595 let preroll = self.src.read_u32be()?;
596 let idx_off = self.src.read_u32be()?;
597 let data_off = self.src.read_u32be()?;
598 let num_streams = self.src.read_u16be()? as usize;
599 let flags = self.src.read_u16be()?;
600 if size > RMVB_PROP_SIZE {
601 self.src.read_skip((size - RMVB_PROP_SIZE) as usize)?;
604 for _ in 0..num_hdr {
605 if self.src.is_eof() {
609 let res = self.parse_chunk(strmgr);
611 Ok(last) => { if last { break; } },
612 Err(DemuxerError::IOError) => { break; },
613 Err(etype) => { return Err(etype); },
616 //println!("now @ {:X} / {}", self.src.tell(), self.data_pos);
617 validate!(self.data_pos > 0);
618 self.src.seek(SeekFrom::Start(self.data_pos))?;
619 let num_packets = self.src.read_u32be()?;
620 let next_data_hdr = self.src.read_u32be()?;
621 self.num_packets = num_packets;
625 fn parse_chunk(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<bool> {
626 let (id, size, ver) = read_chunk(self.src)?;
627 let end_pos = self.src.tell() - 10 + (size as u64);
630 if id == mktag!(b"CONT") { self.parse_content_desc()?; }
631 else if id == mktag!(b"MDPR") { self.parse_mdpr(strmgr)?; }
632 else if id == mktag!(b"DATA") { if self.data_pos == 0 { self.data_pos = self.src.tell(); } }
633 else if id == mktag!(b"INDX") { /* do nothing for now */ }
634 else if id == 0 { return Ok(true); }
635 else { println!("unknown chunk type {:08X}", id); }
637 let cpos = self.src.tell();
639 self.src.read_skip((end_pos - cpos) as usize)?;
643 #[allow(unused_variables)]
644 fn parse_content_desc(&mut self) -> DemuxerResult<()> {
645 let title_len = self.src.read_u16be()? as usize;
646 self.src.read_skip(title_len)?;
647 let author_len = self.src.read_u16be()? as usize;
648 self.src.read_skip(author_len)?;
649 let copywrong_len = self.src.read_u16be()? as usize;
650 self.src.read_skip(copywrong_len)?;
651 let comment_len = self.src.read_u16be()? as usize;
652 self.src.read_skip(comment_len)?;
655 #[allow(unused_variables)]
656 fn parse_mdpr(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
657 let stream_no = self.src.read_u16be()?;
658 //todo check stream_no for duplicates
659 let maxbr = self.src.read_u32be()?;
660 let avgbr = self.src.read_u32be()?;
661 let maxps = self.src.read_u32be()?;
662 let avgps = self.src.read_u32be()?;
663 let start = self.src.read_u32be()?;
664 let preroll = self.src.read_u32be()?;
665 let duration = self.src.read_u32be()?;
666 let sname_size = self.src.read_byte()? as usize;
667 let sname = read_string_size(self.src, sname_size)?;
668 //println!("str #{} sname = {} pkts {}/{} start {} preroll {}", stream_no, sname, maxps, avgps, start, preroll);
669 let mime_size = self.src.read_byte()? as usize;
670 let mime = read_string_size(self.src, mime_size)?;
671 //println!("mime = {}", mime);
672 let edata_size = self.src.read_u32be()? as usize;
673 let edata: Option<Vec<u8>> = if edata_size == 0 { None } else {
674 let mut edvec: Vec<u8> = Vec::with_capacity(edata_size);
675 edvec.resize(edata_size, 0);
676 self.src.read_buf(&mut edvec)?;
679 self.str_ids.push(stream_no);
681 if let Some(edata_) = edata {
682 let mut mr = MemoryReader::new_read(edata_.as_slice());
683 let mut src = ByteReader::new(&mut mr);
685 let tag = src.read_u32be()?;
686 let tag2 = src.peek_u32be()?;
687 //println!("tag1 {:X} tag2 {:X}", tag, tag2);
688 if tag == mktag!('.', 'r', 'a', 0xFD) {
689 let ver = src.read_u16be()?;
690 let ainfo = match ver {
692 parse_aformat3(&mut src)?
695 parse_aformat4(&mut src)?
698 parse_aformat5(&mut src)?
701 println!("unknown version {}", ver);
702 return Err(DemuxerError::InvalidData);
705 println!(" got ainfo {:?}", ainfo);
706 let cname = find_codec_name(RM_AUDIO_CODEC_REGISTER, ainfo.fcc);
707 let srate = ainfo.sample_rate;
708 let soniton = NASoniton::new(ainfo.sample_size as u8, SONITON_FLAG_SIGNED);
709 let ahdr = NAAudioInfo::new(srate, ainfo.channels as u8, soniton, 1);
710 let extradata = if ainfo.edata_size == 0 {
713 let eslice = &edata_[(src.tell() as usize)..];
714 Some(eslice.to_vec())
716 let nainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
717 let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, srate));
718 if res.is_none() { return Err(MemoryError); }
720 let astr = RMAudioStream::new(ainfo.ileave_info);
721 self.streams.push(RMStreamType::Audio(astr));
722 } else if ((tag2 == mktag!('V', 'I', 'D', 'O')) || (tag2 == mktag!('I', 'M', 'A', 'G'))) && ((tag as usize) <= edata_size) {
724 let fcc = src.read_u32be()?;
725 let width = src.read_u16be()? as usize;
726 let height = src.read_u16be()? as usize;
727 let bpp = src.read_u16be()?;
728 let pad_w = src.read_u16be()?;
729 let pad_h = src.read_u16be()?;
731 if tag2 == mktag!('V', 'I', 'D', 'O') {
732 fps = src.read_u32be()?;
736 let extradata: Option<Vec<u8>>;
738 let eslice = &edata_[(src.tell() as usize)..];
739 extradata = Some(eslice.to_vec());
743 let cname = find_codec_name(RM_VIDEO_CODEC_REGISTER, fcc);
745 let vhdr = NAVideoInfo::new(width, height, false, RGB24_FORMAT);
746 let vinfo = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), extradata);
747 let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no as u32, vinfo, 0x10000, fps));
748 if res.is_none() { return Err(DemuxerError::MemoryError); }
750 let vstr = RMVideoStream::new();
751 self.streams.push(RMStreamType::Video(vstr));
752 } else if tag == mktag!(b"LSD:") {
753 let extradata = Some(edata_.to_vec());
755 src.read_skip(4)?; //version
756 let channels = src.read_u16be()?;
757 let samp_size = src.read_u16be()?;
758 let sample_rate = src.read_u32be()?;
760 println!("LSD sr {}, {} ch", sample_rate, channels);
761 let soniton = NASoniton::new(samp_size as u8, SONITON_FLAG_SIGNED);
762 let ahdr = NAAudioInfo::new(sample_rate, channels as u8, soniton, 1);
763 let nainfo = NACodecInfo::new("ralf", NACodecTypeInfo::Audio(ahdr), extradata);
764 let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, sample_rate));
765 if res.is_none() { return Err(MemoryError); }
766 let astr = RMAudioStream::new(None);
767 self.streams.push(RMStreamType::Audio(astr));
769 self.streams.push(RMStreamType::Logical);
773 self.streams.push(RMStreamType::Unknown);
778 /*#[allow(unused_variables)]
779 fn read_pkt_header(&mut self) -> DemuxerResult<()> {
780 let ver = self.src.read_u16be()?;
782 let str_no = self.src.read_u16be()?;
783 let timestamp = self.src.read_u32be()?;
785 let pkt_group = self.src.read_byte()?;
786 let pkt_flags = self.src.read_byte()?;
788 let asm_rule = self.src.read_u16be()?;
789 let asm_flags = self.src.read_byte()?;
795 fn read_string(src: &mut ByteReader) -> DemuxerResult<String> {
796 let mut vec: Vec<u8> = Vec::new();
798 let c = src.read_byte()?;
802 let str = String::from_utf8(vec);
810 fn read_string_size(src: &mut ByteReader, size: usize) -> DemuxerResult<String> {
811 let mut vec: Vec<u8> = Vec::new();
813 let c = src.read_byte()?;
816 let str = String::from_utf8(vec);
825 #[allow(unused_variables)]
826 fn parse_rm_stream(io: &mut ByteReader) -> DemuxerResult<NAStream> {
827 let mimetype = read_string(io)?;
828 let strname = read_string(io)?;
829 let strnum = io.read_u32le()?;
830 let maxbr = io.read_u32le()?;
831 let avgbr = io.read_u32le()?;
832 let maxsize = io.read_u32le()?;
833 let avgsize = io.read_u32le()?;
834 let duration = io.read_u32le()?;
835 let preroll = io.read_u32le()?;
836 let start = io.read_u32le()?;
837 let edatalen = io.read_u32le()? as usize;
838 let mut edata: Vec<u8> = Vec::with_capacity(edatalen);
839 edata.resize(edatalen, 0);
840 io.read_buf(&mut edata)?;
841 let numprops = io.read_u32le()? as usize;
847 #[allow(unused_variables)]
848 fn read_ra_vbr_stream(io: &mut ByteReader) -> DemuxerResult<NAPacket> {
849 let hdrsizesize = io.read_u16le()?;
850 let num_entries = (hdrsizesize / 16) as usize;
851 let mut sizes: Vec<usize> = Vec::with_capacity(num_entries);
852 for _ in 0..num_entries {
853 let sz = io.read_u16le()? as usize;
856 for i in 0..num_entries {
857 //read packet of sizes[i]
867 static RM_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
868 (b"RV10", "realvideo1"),
869 (b"RV20", "realvideo2"),
870 (b"RVTR", "realvideo2"),
871 (b"RV30", "realvideo3"),
872 (b"RV40", "realvideo4"),
873 (b"CLV1", "clearvideo_rm"),
877 static RM_AUDIO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
889 pub struct RealMediaDemuxerCreator { }
891 impl DemuxerCreator for RealMediaDemuxerCreator {
892 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
893 Box::new(RealMediaDemuxer::new(br))
895 fn get_name(&self) -> &'static str { "realmedia" }
906 File::open("assets/RV/rv10_dnet_640x352_realvideo_encoder_4.0.rm").unwrap();
907 // File::open("assets/RV/rv20_cook_640x352_realproducer_plus_8.51.rm").unwrap();
908 // File::open("assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm").unwrap();
909 // File::open("assets/RV/rv30_atrc_384x208_realproducer_plus_8.51.rm").unwrap();
910 // File::open("assets/RV/rv30_chroma_drift.rm").unwrap();
911 // File::open("assets/RV/rv30_weighted_mc.rm").unwrap();
912 // File::open("assets/RV/rv40_weighted_mc.rmvb").unwrap();
913 // File::open("assets/RV/rv40_weighted_mc_2.rmvb").unwrap();
914 // File::open("assets/RV/clv1_sipr_384x208_realvideo_encoder_4.0.rm").unwrap();
915 // File::open("assets/RV/luckynight.rmvb").unwrap();
916 // File::open("assets/RV/rv40_ralf.rmvb").unwrap();
917 let mut fr = FileReader::new_read(&mut file);
918 let mut br = ByteReader::new(&mut fr);
919 let mut dmx = RealMediaDemuxer::new(&mut br);
920 let mut sm = StreamManager::new();
921 dmx.open(&mut sm).unwrap();
924 let pktres = dmx.get_frame(&mut sm);
925 if let Err(e) = pktres {
926 if e == DemuxerError::EOF { break; }
929 let pkt = pktres.unwrap();
930 println!("Got {}", pkt);