nihav-realmedia/src/demuxers/realmedia.rs

   1 use super::*;
   2 use nihav_core::demuxers::DemuxerError::*;
   3 use std::io::SeekFrom;
   4 use std::mem;
   5 use std::fmt;
   6
   7 macro_rules! mktag {
   8     ($a:expr, $b:expr, $c:expr, $d:expr) => ({
   9         (($a as u32) << 24) | (($b as u32) << 16) | (($c as u32) << 8) | ($d as u32)
  10     });
  11     ($arr:expr) => ({
  12         (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
  13     });
  14 }
  15
  16 const RM_SIPRO_BLOCK_SIZES: [usize; 4] = [ 29, 19, 37, 20 ];
  17 const RM_SIPRO_SWAPS:   [[u8; 2]; 38] = [
  18     [  0, 63 ], [  1, 22 ], [  2, 44 ], [  3, 90 ],
  19     [  5, 81 ], [  7, 31 ], [  8, 86 ], [  9, 58 ],
  20     [ 10, 36 ], [ 12, 68 ], [ 13, 39 ], [ 14, 73 ],
  21     [ 15, 53 ], [ 16, 69 ], [ 17, 57 ], [ 19, 88 ],
  22     [ 20, 34 ], [ 21, 71 ], [ 24, 46 ], [ 25, 94 ],
  23     [ 26, 54 ], [ 28, 75 ], [ 29, 50 ], [ 32, 70 ],
  24     [ 33, 92 ], [ 35, 74 ], [ 38, 85 ], [ 40, 56 ],
  25     [ 42, 87 ], [ 43, 65 ], [ 45, 59 ], [ 48, 79 ],
  26     [ 49, 93 ], [ 51, 89 ], [ 55, 95 ], [ 61, 76 ],
  27     [ 67, 83 ], [ 77, 80 ]
  28 ];
  29
  30 struct RMVideoStream {
  31     frame:      Vec<u8>,
  32     hdr_size:   usize,
  33     frame_size: usize,
  34     frame_pos:  usize,
  35 }
  36
  37 impl RMVideoStream {
  38     fn new() -> Self {
  39         RMVideoStream {
  40             frame:      Vec::new(),
  41             hdr_size:   0,
  42             frame_size: 0,
  43             frame_pos:  0,
  44         }
  45     }
  46     fn flush(&mut self) {
  47         self.frame.truncate(0);
  48         self.frame_size = 0;
  49         self.frame_pos  = 0;
  50     }
  51     fn start_slice(&mut self, num_slices: usize, frame_size: usize, data: &[u8]) {
  52         self.hdr_size = num_slices * 8 + 1;
  53         self.frame.resize(frame_size + self.hdr_size, 0);
  54         self.frame[0] = (num_slices - 1) as u8;
  55         self.frame_pos = 0;
  56         self.add_slice(1, data);
  57     }
  58     fn add_slice(&mut self, slice_no: usize, data: &[u8]) {
  59         self.write_slice_info(slice_no);
  60         let dslice = &mut self.frame[self.hdr_size + self.frame_pos..][..data.len()];
  61         dslice.copy_from_slice(data);
  62         self.frame_pos += data.len();
  63     }
  64     fn write_slice_info(&mut self, slice_no: usize) {
  65         let off = 1 + (slice_no - 1) * 8;
  66         self.frame[off + 0] = 0;
  67         self.frame[off + 1] = 0;
  68         self.frame[off + 2] = 0;
  69         self.frame[off + 3] = 1;
  70         self.frame[off + 4] = (self.frame_pos >> 24) as u8;
  71         self.frame[off + 5] = (self.frame_pos >> 16) as u8;
  72         self.frame[off + 6] = (self.frame_pos >>  8) as u8;
  73         self.frame[off + 7] = (self.frame_pos >>  0) as u8;
  74     }
  75     fn get_frame_data(&mut self) -> Vec<u8> {
  76         let mut v: Vec<u8> = Vec::new();
  77         mem::swap(&mut v, &mut self.frame);
  78         self.flush();
  79         v
  80     }
  81 }
  82
  83 #[derive(Clone,Copy,PartialEq)]
  84 enum Deinterleaver {
  85     None,
  86     RA28_8,
  87     Generic,
  88     Sipro,
  89     VBR,
  90 }
  91
  92 struct RMAudioStream {
  93     deint:      Deinterleaver,
  94     iinfo:      Option<InterleaveInfo>,
  95     buf:        Vec<u8>,
  96     sub_packet: usize,
  97 }
  98
  99 const RM_ILEAVE_INT0: u32 = mktag!(b"Int0");
 100 const RM_ILEAVE_INT4: u32 = mktag!(b"Int4");
 101 const RM_ILEAVE_GENR: u32 = mktag!(b"genr");
 102 const RM_ILEAVE_SIPR: u32 = mktag!(b"sipr");
 103 const RM_ILEAVE_VBRF: u32 = mktag!(b"vbrf");
 104 const RM_ILEAVE_VBRS: u32 = mktag!(b"vbrs");
 105
 106 impl RMAudioStream {
 107     fn new(iinfo: Option<InterleaveInfo>) -> Self {
 108         let deint;
 109         let buf: Vec<u8>;
 110         if let Some(info) = iinfo {
 111             deint = match info.id {
 112                     RM_ILEAVE_INT0 => Deinterleaver::None,
 113                     RM_ILEAVE_INT4 => Deinterleaver::RA28_8,
 114                     RM_ILEAVE_GENR => Deinterleaver::Generic,
 115                     RM_ILEAVE_SIPR => Deinterleaver::Sipro,
 116                     RM_ILEAVE_VBRF => Deinterleaver::VBR,
 117                     RM_ILEAVE_VBRS => Deinterleaver::VBR,
 118                     _ => {println!("unknown deint {:X}", info.id); Deinterleaver::None },
 119                 };
 120             match deint {
 121                 Deinterleaver::None     => { buf = Vec::new(); },
 122                 Deinterleaver::RA28_8  |
 123                 Deinterleaver::Generic |
 124                 Deinterleaver::Sipro    => {
 125                         let bsize = (info.frame_size as usize) * (info.factor as usize);
 126                         buf = vec![0; bsize];
 127                     },
 128                 Deinterleaver::VBR      => {
 129                         buf = Vec::new();
 130                     },
 131             };
 132         } else {
 133             deint = Deinterleaver::None;
 134             buf = Vec::new();
 135         }
 136         RMAudioStream { deint, iinfo, buf, sub_packet: 0 }
 137     }
 138     fn read_apackets(&mut self, queued_packets: &mut Vec<NAPacket>, src: &mut ByteReader, stream: NAStreamRef, ts: u32, keyframe: bool, payload_size: usize) -> DemuxerResult<NAPacket> {
 139         let (tb_num, tb_den) = stream.get_timebase();
 140         let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
 141
 142         if keyframe {
 143             self.sub_packet = 0;
 144         }
 145         match self.deint {
 146             Deinterleaver::None     => { return src.read_packet(stream, ts, keyframe, payload_size); },
 147             Deinterleaver::RA28_8   => {
 148                     let iinfo = self.iinfo.unwrap();
 149                     let factor   = iinfo.factor as usize;
 150                     let halffact = factor >> 1;
 151                     let fsize    = iinfo.frame_size as usize;
 152                     let bsize    = iinfo.block_size as usize;
 153                     let ppos     = self.sub_packet;
 154                     for sb in 0..halffact {
 155                         let mut dst = &mut self.buf[sb * 2 * fsize + ppos * bsize..][..bsize];
 156                         src.read_buf(&mut dst)?;
 157                     }
 158                     self.sub_packet += 1;
 159                     if self.sub_packet == factor {
 160                         self.sub_packet = 0;
 161                         return Ok(NAPacket::new(stream, ts, true, self.buf.clone()));
 162                     } else {
 163                         return Err(DemuxerError::TryAgain);
 164                     }
 165                 },
 166             Deinterleaver::Generic  => {
 167                     let iinfo = self.iinfo.unwrap();
 168                     let factor   = iinfo.factor as usize;
 169                     let fsize    = iinfo.frame_size as usize;
 170                     let bsize    = iinfo.block_size as usize;
 171                     let factor2  = fsize / bsize;
 172                     let ppos     = self.sub_packet;
 173
 174                     for sb in 0..factor2 {
 175                         let sb_pos = factor * sb + ((factor + 1) >> 1) * (ppos & 1) + (ppos >> 1);
 176                         let mut dst = &mut self.buf[bsize * sb_pos..][..bsize];
 177                         src.read_buf(&mut dst)?;
 178                     }
 179                 },
 180             Deinterleaver::Sipro    => {
 181                     let iinfo = self.iinfo.unwrap();
 182                     let fsize    = iinfo.frame_size as usize;
 183                     let ppos     = self.sub_packet;
 184
 185                     let mut dst = &mut self.buf[fsize * ppos..][..fsize];
 186                     src.read_buf(&mut dst)?;
 187                 },
 188             Deinterleaver::VBR      => {
 189                     validate!(payload_size >= 5);
 190                     let hdrsizesize         = src.read_u16be()?;
 191                     let num_entries = (hdrsizesize / 16) as usize;
 192                     validate!(payload_size >= num_entries * 3 + 2);
 193                     let mut sizes: Vec<usize> = Vec::with_capacity(num_entries);
 194                     let mut tot_size = 0;
 195                     for _ in 0..num_entries {
 196                         let sz              = src.read_u16be()? as usize;
 197                         tot_size += sz;
 198                         sizes.push(sz);
 199                     }
 200                     validate!(tot_size + num_entries * 2 + 2 == payload_size);
 201                     let pkt_ts = NATimeInfo::new(None, None, None, tb_num, tb_den);
 202                     let mut first = true;
 203                     for size in sizes.iter() {
 204                         let cur_ts = if first { ts } else { pkt_ts };
 205                         first = false;
 206                         let pkt = src.read_packet(stream.clone(), cur_ts, true, *size)?;
 207                         queued_packets.push(pkt);
 208                     }
 209                     queued_packets.reverse();
 210                     let pkt0 = queued_packets.pop().unwrap();
 211                     return Ok(pkt0);
 212                 },
 213         };
 214
 215         let iinfo = self.iinfo.unwrap();
 216         let factor   = iinfo.factor as usize;
 217         let fsize    = if iinfo.block_size != 0 { iinfo.block_size } else { iinfo.frame_size } as usize;
 218
 219         self.sub_packet += 1;
 220         if self.sub_packet < factor {
 221             return Err(DemuxerError::TryAgain);
 222         }
 223
 224         self.sub_packet = 0;
 225
 226         if self.deint == Deinterleaver::Sipro {
 227             sipro_restore(&mut self.buf, factor, iinfo.frame_size as usize);
 228         }
 229
 230         let mut frames_iter = self.buf.chunks(fsize);
 231         let pkt0 = frames_iter.next().unwrap();
 232
 233         let pkt_ts = NATimeInfo::new(None, None, None, tb_num, tb_den);
 234         for pkts in frames_iter {
 235             let pkt = NAPacket::new(stream.clone(), pkt_ts, true, pkts.to_vec());
 236             queued_packets.push(pkt);
 237         }
 238         queued_packets.reverse();
 239         Ok(NAPacket::new(stream, ts, true, pkt0.to_vec()))
 240     }
 241 }
 242
 243 fn sipro_restore(buf: &mut [u8], factor: usize, fsize: usize) {
 244     let stride = factor * fsize * 2 / 96;
 245     for i in 0..38 {
 246         let mut sidx = (RM_SIPRO_SWAPS[i][0] as usize) * stride;
 247         let mut didx = (RM_SIPRO_SWAPS[i][1] as usize) * stride;
 248         for _ in 0..stride {
 249             let in0 = buf[sidx >> 1];
 250             let in1 = buf[didx >> 1];
 251             let nib0 = (in0 >> ((sidx & 1) * 4)) & 0xF;
 252             let nib1 = (in1 >> ((didx & 1) * 4)) & 0xF;
 253
 254             buf[didx >> 1] = (nib0 << (4 * (didx & 1))) | (in1 & (0xF << (4 * (!didx & 1))));
 255             buf[sidx >> 1] = (nib1 << (4 * (sidx & 1))) | (in0 & (0xF << (4 * (!sidx & 1))));
 256
 257             sidx += 1;
 258             didx += 1;
 259         }
 260     }
 261 }
 262
 263 struct SubstreamInfo {
 264     id:         u32,
 265     map:        Vec<u16>,
 266     str_ids:    Vec<u32>,
 267 }
 268
 269 struct MLTIMapper {
 270     sub_info:   Vec<SubstreamInfo>,
 271     sstr_id:    u32,
 272 }
 273
 274 impl MLTIMapper {
 275     fn new() -> Self {
 276         MLTIMapper {
 277             sub_info:   Vec::new(),
 278             sstr_id:    0x10000,
 279         }
 280     }
 281     fn add_stream(&mut self, stream_no: u32) {
 282         let ssinfo = SubstreamInfo { id: stream_no, map: Vec::new(), str_ids: Vec::new() };
 283         self.sub_info.push(ssinfo);
 284     }
 285     fn get_substream_no(&self) -> u32 {
 286         self.sstr_id - 1
 287     }
 288     fn find_idx(&self, stream_no: u32) -> Option<usize> {
 289         self.sub_info.iter().position(|x| x.id == stream_no)
 290     }
 291     fn add_map_rule(&mut self, map_ss: u16) {
 292         let idx = self.sub_info.len() - 1;
 293         self.sub_info[idx].map.push(map_ss);
 294     }
 295     fn add_substream(&mut self) {
 296         let idx = self.sub_info.len() - 1;
 297         self.sub_info[idx].str_ids.push(self.sstr_id);
 298         self.sstr_id += 1;
 299     }
 300     fn is_mlti_stream(&self, stream_no: u32) -> bool {
 301         self.find_idx(stream_no).is_some()
 302     }
 303     fn find_substream(&self, stream_no: u32, grp: u16) -> Option<u32> {
 304         if let Some(idx) = self.find_idx(stream_no) {
 305             if (grp as usize) < self.sub_info[idx].map.len() {
 306                 let sub_id = self.sub_info[idx].map[grp as usize] as usize;
 307                 if sub_id < self.sub_info[idx].str_ids.len() {
 308                     return Some(self.sub_info[idx].str_ids[sub_id]);
 309                 }
 310             }
 311         }
 312         None
 313     }
 314 }
 315
 316 enum RMStreamType {
 317     Audio(RMAudioStream),
 318     Video(RMVideoStream),
 319     Logical,
 320     Unknown,
 321 }
 322
 323 struct CommonStreamData {
 324     streams:        Vec<RMStreamType>,
 325     str_ids:        Vec<u32>,
 326     mlti_mapper:    MLTIMapper,
 327 }
 328
 329 impl CommonStreamData {
 330     fn new() -> Self {
 331         CommonStreamData {
 332             streams:        Vec::new(),
 333             str_ids:        Vec::new(),
 334             mlti_mapper:    MLTIMapper::new(),
 335         }
 336     }
 337     fn get_stream_id(&self, str_no: u32, pkt_grp: u16) -> u32 {
 338         if !self.mlti_mapper.is_mlti_stream(str_no) {
 339             str_no
 340         } else {
 341             self.mlti_mapper.find_substream(str_no, pkt_grp).unwrap()
 342         }
 343     }
 344     fn find_stream(&self, stream_id: u32) -> Option<usize> {
 345         self.str_ids.iter().position(|x| *x == stream_id)
 346     }
 347 }
 348
 349 struct RealMediaDemuxer<'a> {
 350     src:            &'a mut ByteReader<'a>,
 351     data_pos:       u64,
 352     data_end:       u64,
 353     next_data:      u64,
 354     data_ver:       u16,
 355     num_packets:    u32,
 356     cur_packet:     u32,
 357
 358     str_data:       CommonStreamData,
 359
 360     data_chunks:    Vec<(u64, u32, u16)>,
 361     cur_data_chunk: usize,
 362
 363     queued_pkts:    Vec<NAPacket>,
 364     slice_buf:      Vec<u8>,
 365 }
 366
 367 fn find_codec_name(registry: &[(&[u8;4], &'static str)], fcc: u32) -> &'static str {
 368     for &(fourcc, name) in registry {
 369         if mktag!(fourcc) == fcc { return name; }
 370     }
 371     "unknown"
 372 }
 373
 374 fn read_14or30(src: &mut ByteReader) -> DemuxerResult<(bool, u32)> {
 375     let tmp = src.read_u16be()?;
 376     let flag = (tmp & 0x8000) != 0;
 377     if (tmp & 0x4000) == 0x4000 {
 378         Ok((flag, ((tmp & 0x3FFF) as u32)))
 379     } else {
 380         let val = ((tmp as u32) << 16) | (src.read_u16be()? as u32);
 381         Ok((flag, val & 0x3FFFFFFF))
 382     }
 383 }
 384
 385 fn read_video_buf(src: &mut ByteReader, stream: NAStreamRef, ts: u32, keyframe: bool, frame_size: usize) -> DemuxerResult<NAPacket> {
 386     let size = (frame_size as usize) + 9;
 387     let mut vec: Vec<u8> = vec![0; size];
 388     //v[0] = 0; // 1 slice
 389     vec[4] = 1;
 390     src.read_buf(&mut vec[9..])?;
 391
 392     let (tb_num, tb_den) = stream.get_timebase();
 393     let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
 394     Ok(NAPacket::new(stream, ts, keyframe, vec))
 395 }
 396
 397 fn read_multiple_frame(src: &mut ByteReader, stream: NAStreamRef, keyframe: bool, skip_mtype: bool) -> DemuxerResult<NAPacket> {
 398     if !skip_mtype {
 399         let mtype       = src.read_byte()?;
 400         validate!(mtype == 0xC0);
 401     }
 402     let (_, frame_size) = read_14or30(src)?;
 403     let (_, timestamp)  = read_14or30(src)?;
 404     let _seq_no         = src.read_byte()?;
 405 //println!("  multiple frame size {} ts {} seq {}", frame_size, timestamp, seq_no);
 406
 407     read_video_buf(src, stream, timestamp, keyframe, frame_size as usize)
 408 }
 409
 410 struct RMDemuxCommon {}
 411
 412 impl RMDemuxCommon {
 413     fn parse_stream_info(str_data: &mut CommonStreamData, strmgr: &mut StreamManager, stream_no: u32, edata: &Vec<u8>) -> DemuxerResult<bool> {
 414         let mut is_mlti = false;
 415         let mut mr = MemoryReader::new_read(edata.as_slice());
 416         let mut src = ByteReader::new(&mut mr);
 417         let tag  = src.read_u32be()?;
 418         let tag2 = src.peek_u32be()?;
 419 //println!("tag1 {:X} tag2 {:X}", tag, tag2);
 420         if tag == mktag!('.', 'r', 'a', 0xFD) {
 421             Self::parse_audio_stream(strmgr, &mut str_data.streams, stream_no, &mut src, edata.as_slice())?;
 422         } else if ((tag2 == mktag!('V', 'I', 'D', 'O')) || (tag2 == mktag!('I', 'M', 'A', 'G'))) && ((tag as usize) <= edata.len()) {
 423             Self::parse_video_stream(strmgr, &mut str_data.streams, stream_no, &mut src, edata.as_slice(), tag2)?;
 424         } else if tag == mktag!(b"LSD:") {
 425             let extradata = Some(edata.to_owned());
 426
 427             src.read_skip(4)?; //version
 428             let channels    = src.read_u16be()?;
 429             let samp_size   = src.read_u16be()?;
 430             let sample_rate = src.read_u32be()?;
 431
 432             println!("LSD sr {}, {} ch", sample_rate, channels);
 433             let soniton = NASoniton::new(samp_size as u8, SONITON_FLAG_SIGNED);
 434             let ahdr = NAAudioInfo::new(sample_rate, channels as u8, soniton, 1);
 435             let nainfo = NACodecInfo::new("ralf", NACodecTypeInfo::Audio(ahdr), extradata);
 436             let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, 1000));
 437             if res.is_none() { return Err(MemoryError); }
 438             let astr = RMAudioStream::new(None);
 439             str_data.streams.push(RMStreamType::Audio(astr));
 440         } else if tag == mktag!(b"MLTI") {
 441             is_mlti = true;
 442             let num_rules       = src.read_u16be()? as usize;
 443             let mut max_sub = 0;
 444             str_data.mlti_mapper.add_stream(stream_no);
 445             for _ in 0..num_rules {
 446                 let substr      = src.read_u16be()?;
 447                 max_sub = max_sub.max(substr);
 448                 str_data.mlti_mapper.add_map_rule(substr);
 449             }
 450             let num_substreams  = src.read_u16be()? as usize;
 451             validate!(num_substreams > (max_sub as usize));
 452             for _ in 0..num_substreams {
 453                 let hdr_size    = src.read_u32be()? as usize;
 454                 validate!(hdr_size > 8);
 455                 let pos = src.tell() as usize;
 456                 src.read_skip(hdr_size)?;
 457                 str_data.mlti_mapper.add_substream();
 458                 {
 459                     let hdrsrc = &edata[pos..][..hdr_size];
 460                     let mut mr = MemoryReader::new_read(hdrsrc);
 461                     let mut hsrc = ByteReader::new(&mut mr);
 462
 463                     let tag  = hsrc.read_u32be()?;
 464                     let tag2 = hsrc.peek_u32be()?;
 465                     let stream_no = str_data.mlti_mapper.get_substream_no();
 466 //todo check that all substreams are of the same type");
 467                     if tag == mktag!('.', 'r', 'a', 0xFD) {
 468                         Self::parse_audio_stream(strmgr, &mut str_data.streams, stream_no, &mut hsrc, hdrsrc)?;
 469                     } else if (tag2 == mktag!('V', 'I', 'D', 'O')) && ((tag as usize) <= hdr_size) {
 470                         Self::parse_video_stream(strmgr, &mut str_data.streams, stream_no, &mut hsrc, hdrsrc, tag2)?;
 471                     } else {
 472 println!("unknown MLTI substream {:08X} / {:08X}", tag, tag2);
 473                         return Err(DemuxerError::InvalidData);
 474                     }
 475                     str_data.str_ids.push(stream_no);
 476                 }
 477             }
 478         } else {
 479             str_data.streams.push(RMStreamType::Logical);
 480         }
 481         Ok(is_mlti)
 482     }
 483     fn parse_audio_stream(strmgr: &mut StreamManager, streams: &mut Vec<RMStreamType>, stream_no: u32, src: &mut ByteReader, edata_: &[u8]) -> DemuxerResult<()> {
 484         let ver         = src.read_u16be()?;
 485         let ainfo = match ver {
 486             3 => {
 487                     parse_aformat3(src)?
 488                 },
 489             4 => {
 490                     parse_aformat4(src)?
 491                 },
 492             5 => {
 493                     parse_aformat5(src)?
 494                 },
 495             _ => {
 496                     println!("unknown version {}", ver);
 497                     return Err(DemuxerError::InvalidData);
 498                 },
 499         };
 500 println!(" got ainfo {:?}", ainfo);
 501         let cname = find_codec_name(RM_AUDIO_CODEC_REGISTER, ainfo.fcc);
 502         let blk_size = if ainfo.fcc != mktag!(b"sipr") {
 503                 ainfo.granularity as usize
 504             } else {
 505                 validate!(ainfo.flavor <= 3);
 506                 RM_SIPRO_BLOCK_SIZES[ainfo.flavor as usize]
 507             };
 508         let srate = ainfo.sample_rate;
 509         let soniton = NASoniton::new(ainfo.sample_size as u8, SONITON_FLAG_SIGNED);
 510         let ahdr = NAAudioInfo::new(srate, ainfo.channels as u8, soniton, blk_size);
 511         let extradata = if ainfo.edata_size == 0 {
 512                 None
 513             } else {
 514                 let eslice = &edata_[(src.tell() as usize)..];
 515                 Some(eslice.to_vec())
 516             };
 517         let nainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
 518         let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, 1000));
 519         if res.is_none() { return Err(MemoryError); }
 520
 521         let astr = RMAudioStream::new(ainfo.ileave_info);
 522         streams.push(RMStreamType::Audio(astr));
 523         Ok(())
 524     }
 525 #[allow(unused_variables)]
 526     fn parse_video_stream(strmgr: &mut StreamManager, streams: &mut Vec<RMStreamType>, stream_no: u32, src: &mut ByteReader, edata_: &[u8], tag2: u32) -> DemuxerResult<()> {
 527         src.read_skip(4)?;
 528         let fcc         = src.read_u32be()?;
 529         let width       = src.read_u16be()? as usize;
 530         let height      = src.read_u16be()? as usize;
 531         let bpp         = src.read_u16be()?;
 532         let pad_w       = src.read_u16be()?;
 533         let pad_h       = src.read_u16be()?;
 534         let _fps;
 535         if tag2 == mktag!('V', 'I', 'D', 'O') {
 536             _fps        = src.read_u32be()?;
 537         } else {
 538             _fps = 0x10000;
 539         }
 540         let extradata: Option<Vec<u8>>;
 541         if src.left() > 0 {
 542             let eslice = &edata_[(src.tell() as usize)..];
 543             extradata = Some(eslice.to_vec());
 544         } else {
 545             extradata = None;
 546         }
 547         let cname = find_codec_name(RM_VIDEO_CODEC_REGISTER, fcc);
 548
 549         let vhdr = NAVideoInfo::new(width, height, false, RGB24_FORMAT);
 550         let vinfo = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), extradata);
 551         let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no as u32, vinfo, 1, 1000));
 552         if res.is_none() { return Err(DemuxerError::MemoryError); }
 553
 554         let vstr = RMVideoStream::new();
 555         streams.push(RMStreamType::Video(vstr));
 556         Ok(())
 557     }
 558 #[allow(unused_variables)]
 559     fn parse_packet_payload(src: &mut ByteReader, rmstream: &mut RMStreamType, stream: NAStreamRef, slice_buf: &mut Vec<u8>, queued_pkts: &mut Vec<NAPacket>, keyframe: bool, ts: u32, payload_size: usize) -> DemuxerResult<NAPacket> {
 560         match rmstream {
 561             RMStreamType::Video(ref mut vstr) => {
 562
 563                     let pos = src.tell();
 564                     let b0          = src.read_byte()?;
 565                     match b0 >> 6 {
 566                         0 => { // partial frame
 567                                 let b1  = src.read_byte()?;
 568                                 let hdr1 = ((b0 as u16) << 8) | (b1 as u16);
 569                                 let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
 570                                 let packet_num = hdr1 & 0x7F;
 571                                 let (_, frame_size) = read_14or30(src)?;
 572                                 let (_, off)        = read_14or30(src)?;
 573                                 let seq_no = src.read_byte()?;
 574 //println!(" mode 0 pkt {}/{} off {}/{} seq {}", packet_num, num_pkts, off, frame_size, seq_no);
 575                                 let hdr_skip = (src.tell() - pos) as usize;
 576
 577                                 let slice_size = (payload_size - hdr_skip) as usize;
 578                                 slice_buf.resize(slice_size, 0);
 579                                 src.read_buf(slice_buf.as_mut_slice())?;
 580                                 if packet_num == 1 {
 581                                     vstr.start_slice(num_pkts, frame_size as usize, slice_buf.as_slice());
 582                                 } else {
 583                                     vstr.add_slice(packet_num as usize, slice_buf.as_slice());
 584                                 }
 585                                 if (packet_num as usize) < num_pkts {
 586                                     return Err(DemuxerError::TryAgain);
 587                                 }
 588                                 //todo: check if full frame is received
 589                                 let (tb_num, tb_den) = stream.get_timebase();
 590                                 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
 591                                 let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
 592                                 Ok(pkt)
 593                             },
 594                         1 => { // whole frame
 595                                 let seq_no = src.read_byte()?;
 596 //println!(" mode 1 seq {}", seq_no);
 597                                 read_video_buf(src, stream, ts, keyframe, payload_size - 2)
 598                             },
 599                         2 => { // last partial frame
 600                                 let b1  = src.read_byte()?;
 601                                 let hdr1 = ((b0 as u16) << 8) | (b1 as u16);
 602                                 let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
 603                                 let packet_num = hdr1 & 0x7F;
 604                                 let (_, frame_size) = read_14or30(src)?;
 605                                 let (_, tail_size)  = read_14or30(src)?;
 606                                 let seq_no = src.read_byte()?;
 607 //println!(" mode 2 pkt {}/{} tail {}/{} seq {}", packet_num, num_pkts, tail_size, frame_size, seq_no);
 608                                 slice_buf.resize(tail_size as usize, 0);
 609                                 src.read_buf(slice_buf.as_mut_slice())?;
 610                                 if packet_num == 1 && frame_size == tail_size {
 611                                     vstr.start_slice(num_pkts, frame_size as usize, slice_buf.as_slice());
 612                                 } else {
 613                                     vstr.add_slice(packet_num as usize, slice_buf.as_slice());
 614                                 }
 615
 616                                 while src.tell() < pos + (payload_size as u64) {
 617                                     let res = read_multiple_frame(src, stream.clone(), false, false);
 618                                     if res.is_err() { break; }
 619                                     queued_pkts.push(res.unwrap());
 620                                 }
 621                                 queued_pkts.reverse();
 622                                 let (tb_num, tb_den) = stream.get_timebase();
 623                                 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
 624                                 let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
 625                                 Ok(pkt)
 626                         },
 627                     _ => { // multiple frames
 628 //println!(" mode 3");
 629                                 let res = read_multiple_frame(src, stream.clone(), keyframe, true);
 630                                 if res.is_err() { return res; }
 631                                 while src.tell() < pos + (payload_size as u64) {
 632                                     let res = read_multiple_frame(src, stream.clone(), false, false);
 633                                     if res.is_err() { break; }
 634                                     queued_pkts.push(res.unwrap());
 635                                 }
 636                                 queued_pkts.reverse();
 637                                 res
 638                             },
 639                     }
 640                 },
 641             RMStreamType::Audio(ref mut astr) => {
 642                     astr.read_apackets(queued_pkts, src, stream, ts, keyframe, payload_size)
 643                 },
 644             _ => {
 645                       src.read_skip(payload_size)?;
 646                     Err(DemuxerError::InvalidData)
 647                 },
 648         }
 649     }
 650 }
 651
 652 impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> {
 653     fn open(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()> {
 654         self.read_header(strmgr, seek_idx)?;
 655         Ok(())
 656     }
 657
 658 #[allow(unused_variables)]
 659     fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
 660         if !self.queued_pkts.is_empty() {
 661             let pkt = self.queued_pkts.pop().unwrap();
 662             return Ok(pkt);
 663         }
 664         loop {
 665             if (self.cur_packet >= self.num_packets) || (self.src.tell() >= self.data_end) {
 666                 self.cur_data_chunk += 1;
 667                 if self.cur_data_chunk < self.data_chunks.len() {
 668                     let (pos, _, _) = self.data_chunks[self.cur_data_chunk];
 669                     self.src.seek(SeekFrom::Start(pos))?;
 670                     let res = read_chunk(self.src);
 671                     if let Ok((id, size, ver)) = res {
 672                         self.data_pos = self.src.tell();
 673                         self.data_ver = ver;
 674                         self.data_end = self.data_pos + (size as u64);
 675                         if self.parse_data_start().is_ok() {
 676                             continue;
 677                         }
 678                     }
 679                 }
 680                 return Err(DemuxerError::EOF);
 681             }
 682
 683             let pkt_start = self.src.tell();
 684             let ver             = self.src.read_u16be()?;
 685             validate!(ver <= 1);
 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()?;
 689             let pkt_grp;
 690             let flags;
 691             if ver == 0 {
 692                 pkt_grp         = self.src.read_byte()? as u16;
 693                 flags           = self.src.read_byte()?;
 694             } else {
 695                 //asm_rule        = self.src.read_u16be()?;
 696                 //asm_flags       = self.src.read_byte()?;
 697                 self.src.read_skip(2)?;
 698                 pkt_grp = 0;
 699                 self.src.read_skip(1)?;
 700                 flags = 0;
 701             }
 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;
 705
 706             let payload_size = len - (hdr_size as usize);
 707
 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);
 710             if sr.is_none() {
 711 //println!("stream {} not found", str_no);
 712                 self.src.read_skip(payload_size)?;
 713                 return Err(DemuxerError::InvalidData);
 714             }
 715             let str_id = sr.unwrap();
 716
 717             let streamres = strmgr.get_stream_by_id(stream_id);
 718             if streamres.is_none() {
 719                 self.src.read_skip(payload_size)?;
 720                 continue;
 721             }
 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)?;
 726                 continue;
 727             }
 728             //todo skip unwanted packet
 729             let keyframe = (flags & KEYFRAME_FLAG) != 0;
 730
 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 {
 733                 continue;
 734             } else {
 735                 return ret;
 736             }
 737         }
 738     }
 739
 740     #[allow(unused_variables)]
 741     fn seek(&mut self, time: u64, seek_idx: &SeekIndex) -> DemuxerResult<()> {
 742         self.queued_pkts.clear();
 743         let ret = seek_idx.find_pos(time);
 744         if ret.is_none() {
 745             return Err(DemuxerError::SeekError);
 746         }
 747         let ret = ret.unwrap();
 748         let seek_pos = ret.pos;
 749         for (pos, size, ver) in self.data_chunks.iter() {
 750             if seek_pos < *pos { continue; }
 751             let end = *pos + (*size as u64);
 752             if seek_pos < end {
 753                 self.cur_packet = 0;
 754                 self.data_pos = seek_pos;
 755                 self.data_ver = *ver;
 756                 self.data_end = end;
 757                 self.src.seek(SeekFrom::Start(seek_pos))?;
 758                 return Ok(());
 759             }
 760         }
 761         Err(DemuxerError::SeekError)
 762     }
 763 }
 764
 765 fn read_chunk(src: &mut ByteReader) -> DemuxerResult<(u32, u32, u16)> {
 766     let id      = src.read_u32be()?;
 767 if id == 0 { return Ok((0, 0, 0)); }
 768     let size    = src.read_u32be()?;
 769 if size == 0 {
 770     let ver     = src.read_u16be()?;
 771     validate!(ver <= 2);
 772     return Ok((id, 0x0FFFFFFF, ver));
 773 }
 774     validate!(size >= 10);
 775     let ver     = src.read_u16be()?;
 776     validate!(ver <= 2);
 777     Ok((id, size, ver))
 778 }
 779
 780 #[derive(Clone,Copy,Debug)]
 781 struct InterleaveInfo {
 782     id:         u32,
 783     factor:     u16,
 784     block_size: u16,
 785     frame_size: u16,
 786 }
 787
 788 #[derive(Clone,Copy,Debug)]
 789 struct RealAudioInfo {
 790     fcc:                u32,
 791     sample_rate:        u32,
 792     sample_size:        u16,
 793     flavor:             u16,
 794     channels:           u16,
 795     channel_mask:       u32,
 796     granularity:        u32,
 797     bytes_per_minute:   u32,
 798     total_bytes:        u32,
 799     edata_size:         u32,
 800     ileave_info:        Option<InterleaveInfo>
 801 }
 802
 803 fn skip_ra_metadata(src: &mut ByteReader) -> DemuxerResult<()> {
 804     let title_len           = src.read_byte()? as usize;
 805     src.read_skip(title_len)?;
 806     let author_len          = src.read_byte()? as usize;
 807     src.read_skip(author_len)?;
 808     let copywrong_len       = src.read_byte()? as usize;
 809     src.read_skip(copywrong_len)?;
 810     let comment_len         = src.read_byte()? as usize;
 811     src.read_skip(comment_len)?;
 812     Ok(())
 813 }
 814
 815 #[allow(unused_variables)]
 816 fn parse_aformat3(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
 817     let start = src.tell();
 818     let header_len          = src.read_u16be()?;
 819     validate!(header_len >= 24);
 820     let flavor              = src.read_u16be()?;
 821     let granularity         = src.read_u32be()?;
 822     let bytes_per_minute    = src.read_u32be()?;
 823     let total_bytes         = src.read_u32be()?;
 824
 825     skip_ra_metadata(src)?;
 826
 827     let _can_copy           = src.read_byte()?;
 828     let fcc_len             = src.read_byte()?;
 829     validate!(fcc_len == 4);
 830     let fcc                 = src.read_u32be()?;
 831
 832     let end = src.tell();
 833     validate!(end - start <= (header_len as u64) + 2);
 834
 835     Ok(RealAudioInfo {
 836         fcc, flavor,
 837         sample_rate: 8000, sample_size: 16, channels: 1, channel_mask: 0,
 838         granularity, bytes_per_minute,
 839         total_bytes, edata_size: 0,
 840         ileave_info: None,
 841     })
 842 }
 843
 844 #[allow(unused_variables)]
 845 fn parse_aformat4(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
 846     let start = src.tell();
 847     src.read_skip(2)?; // zeroes
 848     let id                  = src.read_u32be()?;
 849     validate!(id == mktag!(b".ra4"));
 850     let data_size           = src.read_u32be()?;
 851     let _ver4               = src.read_u16be()?; // should be 4
 852     let header_size         = src.read_u32be()?;
 853     let flavor              = src.read_u16be()?;
 854     let granularity         = src.read_u32be()?;
 855     let total_bytes         = src.read_u32be()?;
 856     let bytes_per_minute    = src.read_u32be()?;
 857     let _bytes_per_minute2  = src.read_u32be()?;
 858     let ileave_factor       = src.read_u16be()?;
 859     let ileave_block_size   = src.read_u16be()?;
 860     let _user_data          = src.read_u16be()?;
 861     let sample_rate         = src.read_u32be()?;
 862     let sample_size         = src.read_u32be()?;
 863     let channels            = src.read_u16be()?;
 864     let interleaver_id_len  = src.read_byte()?;
 865     validate!(interleaver_id_len == 4);
 866     let interleaver_id      = src.read_u32be()?;
 867     let fcc_len             = src.read_byte()?;
 868     validate!(fcc_len == 4);
 869     let fcc                 = src.read_u32be()?;
 870     let is_interleaved      = src.read_byte()?;
 871     let _can_copy           = src.read_byte()?;
 872     let _stream_type        = src.read_byte()?;
 873
 874     skip_ra_metadata(src)?;
 875
 876     let end = src.tell();
 877     validate!(end - start <= (header_size as u64) + 10);
 878
 879     let ileave_info = if is_interleaved != 0 {
 880             Some(InterleaveInfo {
 881                     id: interleaver_id, factor: ileave_factor, block_size: granularity as u16,
 882                     frame_size: ileave_block_size,
 883                 })
 884         } else {
 885             None
 886         };
 887
 888     Ok(RealAudioInfo {
 889         fcc, flavor,
 890         sample_rate, sample_size: sample_size as u16, channels, channel_mask: 0,
 891         granularity, bytes_per_minute,
 892         total_bytes: total_bytes & 0xFFFFFF, edata_size: 0,
 893         ileave_info,
 894     })
 895 }
 896
 897 #[allow(unused_variables)]
 898 fn parse_aformat5(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
 899     let start = src.tell();
 900     src.read_skip(2)?; // zeroes
 901     let id                  = src.read_u32be()?;
 902     validate!((id == mktag!(b".ra5")) || (id == mktag!(b".ra4")));
 903     let data_size           = src.read_u32be()?;
 904     let _ver5               = src.read_u16be()?; // should be 5
 905     let header_size         = src.read_u32be()?;
 906     let flavor              = src.read_u16be()?;
 907     let granularity         = src.read_u32be()?;
 908     let total_bytes         = src.read_u32be()?;
 909     let bytes_per_minute    = src.read_u32be()?;
 910     let _bytes_per_minute2  = src.read_u32be()?;
 911     let ileave_factor       = src.read_u16be()?;
 912     let frame_size          = src.read_u16be()?;
 913     let ileave_block_size   = src.read_u16be()?;
 914     let user_data           = src.read_u32be()?;
 915     let _sample_rate1       = src.read_u16be()?;
 916     let sample_rate         = src.read_u32be()?;
 917     let sample_size         = src.read_u32be()?;
 918     let channels            = src.read_u16be()?;
 919     let interleaver_id      = src.read_u32be()?;
 920     let fcc                 = src.read_u32be()?;
 921     let is_interleaved      = src.read_byte()?;
 922     let _can_copy           = src.read_byte()?;
 923     let _stream_type        = src.read_byte()?;
 924     let has_ileave_pattern  = src.read_byte()?;
 925     if has_ileave_pattern != 0 {
 926 unimplemented!("ra5 interleave pattern");
 927     }
 928     let mut edata_size          = src.read_u32be()?;
 929     let end = src.tell();
 930     if id == mktag!(b".ra5") {
 931         validate!(end - start <= (header_size as u64) + 10);
 932 //    src.read_skip(((end - start) as usize) - (header_size as usize) - 10)?;
 933     } else {
 934         validate!(end - start <= (header_size as u64) + 15);
 935     }
 936
 937     let ileave_info = if is_interleaved != 0 {
 938             Some(InterleaveInfo {
 939                     id: interleaver_id, factor: ileave_factor, block_size: ileave_block_size, frame_size,
 940                 })
 941         } else {
 942             None
 943         };
 944     if (fcc == mktag!(b"raac")) || (fcc == mktag!(b"racp")) {
 945         validate!(edata_size > 1);
 946         edata_size -= 1;
 947         src.read_skip(1)?;
 948     }
 949
 950     Ok(RealAudioInfo {
 951         fcc, flavor,
 952         sample_rate, sample_size: sample_size as u16, channels, channel_mask: 0,
 953         granularity, bytes_per_minute,
 954         total_bytes: total_bytes & 0xFFFFFF, edata_size,
 955         ileave_info,
 956     })
 957 }
 958
 959 const RMVB_HDR_SIZE:  u32 = 18;
 960 const RMVB_PROP_SIZE: u32 = 50;
 961 const KEYFRAME_FLAG: u8 = 0x02;
 962
 963 impl<'a> RealMediaDemuxer<'a> {
 964     fn new(io: &'a mut ByteReader<'a>) -> Self {
 965         RealMediaDemuxer {
 966             src:            io,
 967             data_pos:       0,
 968             data_end:       0,
 969             next_data:      0,
 970             data_ver:       0,
 971             num_packets:    0,
 972             cur_packet:     0,
 973             str_data:       CommonStreamData::new(),
 974             data_chunks:    Vec::new(),
 975             cur_data_chunk: 0,
 976             queued_pkts:    Vec::new(),
 977             slice_buf:      Vec::new(),
 978         }
 979     }
 980 #[allow(unused_variables)]
 981     fn read_header(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()> {
 982         let (id, size, ver) = read_chunk(self.src)?;
 983         validate!((id == mktag!(b".RMF")) || (id == mktag!(b".RMP")));
 984         validate!(size >= RMVB_HDR_SIZE);
 985         let fver    = self.src.read_u32be()?;
 986         validate!(fver <= 1);
 987         let num_hdr = self.src.read_u32be()? as usize;
 988         validate!(num_hdr >= 1);
 989         if size > RMVB_HDR_SIZE {
 990             self.src.read_skip((size - RMVB_HDR_SIZE) as usize)?;
 991         }
 992
 993         let (id, size, ver) = read_chunk(self.src)?;
 994         let prop_size = if ver == 0 { RMVB_PROP_SIZE } else { RMVB_PROP_SIZE + 4 };
 995         validate!(size >= prop_size);
 996         validate!((ver == 0) || (ver == 2));
 997         let maxbr       = self.src.read_u32be()?;
 998         let avgbr       = self.src.read_u32be()?;
 999         let maxps       = self.src.read_u32be()?;
1000         let avgps       = self.src.read_u32be()?;
1001         let num_pkt     = self.src.read_u32be()? as usize;
1002         let duration    = self.src.read_u32be()?;
1003         let preroll     = self.src.read_u32be()?;
1004         if ver == 2 {
1005                           self.src.read_skip(4)?;
1006         }
1007         let idx_off     = self.src.read_u32be()?;
1008         let data_off    = self.src.read_u32be()?;
1009         let num_streams = self.src.read_u16be()? as usize;
1010         let flags       = self.src.read_u16be()?;
1011         if size > prop_size {
1012             self.src.read_skip((size - prop_size) as usize)?;
1013         }
1014
1015         for _ in 0..num_hdr {
1016             if self.src.is_eof() {
1017                 //warn maybe?
1018                 break;
1019             }
1020             let res = self.parse_chunk(strmgr, seek_idx);
1021             match res {
1022                 Ok(last) => { if last { break; } },
1023                 Err(DemuxerError::IOError) => { break; },
1024                 Err(etype) => {
1025                         if self.data_chunks.len() == 0 { // data is not found, report error
1026                             return Err(etype);
1027                         }
1028                     },
1029             };
1030         }
1031 //println!("now @ {:X} / {}", self.src.tell(), self.data_pos);
1032         validate!(self.data_chunks.len() > 0);
1033         self.cur_data_chunk = 0;
1034         let (pos, size, ver) = self.data_chunks[self.cur_data_chunk];
1035         self.data_pos = pos;
1036         self.data_ver = ver;
1037         self.data_end = pos + (size as u64);
1038         self.src.seek(SeekFrom::Start(self.data_pos + 10))?;
1039         self.parse_data_start()?;
1040         Ok(())
1041     }
1042     fn parse_data_start(&mut self) -> DemuxerResult<()> {
1043         let num_packets     = self.src.read_u32be()?;
1044         if self.data_ver == 2 {
1045                               self.src.read_skip(12)?; // zeroes?
1046         }
1047         let next_data_hdr   = self.src.read_u32be()?;
1048         self.num_packets = if num_packets > 0 { num_packets } else { 0xFFFFFF };
1049         self.cur_packet  = 0;
1050         self.next_data   = next_data_hdr as u64;
1051         Ok(())
1052     }
1053     fn parse_chunk(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<bool> {
1054         let (id, size, ver) = read_chunk(self.src)?;
1055         let end_pos = self.src.tell() - 10 + (size as u64);
1056
1057         validate!((ver == 0) || (ver == 2));
1058              if id == mktag!(b"CONT") { self.parse_content_desc()?; }
1059         else if id == mktag!(b"MDPR") { self.parse_mdpr(strmgr)?; }
1060         else if id == mktag!(b"DATA") {
1061             self.data_chunks.push((self.src.tell() - 10, size, ver));
1062         }
1063         else if id == mktag!(b"INDX") {
1064             if !seek_idx.skip_index {
1065                 self.parse_index(seek_idx, (size as usize) - 10, ver)?;
1066             }
1067         }
1068         else if id == 0               { return Ok(true); }
1069         else                          { println!("unknown chunk type {:08X}", id); }
1070
1071         let cpos = self.src.tell();
1072         if cpos < end_pos {
1073             self.src.read_skip((end_pos - cpos) as usize)?;
1074         }
1075         Ok(false)
1076     }
1077 #[allow(unused_variables)]
1078     fn parse_content_desc(&mut self) -> DemuxerResult<()> {
1079         let title_len       = self.src.read_u16be()? as usize;
1080         self.src.read_skip(title_len)?;
1081         let author_len      = self.src.read_u16be()? as usize;
1082         self.src.read_skip(author_len)?;
1083         let copywrong_len   = self.src.read_u16be()? as usize;
1084         self.src.read_skip(copywrong_len)?;
1085         let comment_len     = self.src.read_u16be()? as usize;
1086         self.src.read_skip(comment_len)?;
1087         Ok(())
1088     }
1089 #[allow(unused_variables)]
1090     fn parse_mdpr(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
1091         let stream_no       = self.src.read_u16be()? as u32;
1092 //todo check stream_no for duplicates
1093         let maxbr           = self.src.read_u32be()?;
1094         let avgbr           = self.src.read_u32be()?;
1095         let maxps           = self.src.read_u32be()?;
1096         let avgps           = self.src.read_u32be()?;
1097         let start           = self.src.read_u32be()?;
1098         let preroll         = self.src.read_u32be()?;
1099         let duration        = self.src.read_u32be()?;
1100         let sname_size      = self.src.read_byte()? as usize;
1101         let sname           = read_string_size(self.src, sname_size)?;
1102 //println!("str #{} sname = {} pkts {}/{} start {} preroll {}", stream_no, sname, maxps, avgps, start, preroll);
1103         let mime_size       = self.src.read_byte()? as usize;
1104         let mime            = read_string_size(self.src, mime_size)?;
1105 //println!("mime = {}", mime);
1106         let edata_size      = self.src.read_u32be()? as usize;
1107         let edata: Option<Vec<u8>> = if edata_size == 0 { None } else {
1108             let mut edvec: Vec<u8> = vec![0; edata_size];
1109             self.src.read_buf(&mut edvec)?;
1110             Some(edvec)
1111         };
1112         let mut is_mlti = false;
1113         if edata_size > 8 {
1114             if let Some(edata_) = edata {
1115                 is_mlti = RMDemuxCommon::parse_stream_info(&mut self.str_data, strmgr, stream_no, &edata_)?;
1116             }
1117         } else {
1118             self.str_data.streams.push(RMStreamType::Unknown);
1119         }
1120         if !is_mlti {
1121             self.str_data.str_ids.push(stream_no);
1122         }
1123
1124         Ok(())
1125     }
1126     fn parse_index(&mut self, seek_idx: &mut SeekIndex, chunk_size: usize, ver: u16) -> DemuxerResult<()> {
1127         if ver != 0 { return Ok(()); }
1128         let num_entries     = self.src.read_u32be()? as usize;
1129         let str_id          = self.src.read_u16be()? as u32;
1130         let _next_idx       = self.src.read_u32be()?;
1131         validate!(chunk_size == num_entries * 14 + 10);
1132         if num_entries == 0 { return Ok(()); }
1133
1134         seek_idx.add_stream(str_id);
1135         let idx = seek_idx.get_stream_index(str_id).unwrap();
1136         for _ in 0..num_entries {
1137             let ver         = self.src.read_u16be()? as u32;
1138             validate!(ver == 0);
1139             let ts          = self.src.read_u32be()? as u64;
1140             let pos         = self.src.read_u32be()? as u64;
1141             let _pkt_no     = self.src.read_u32be()?;
1142             idx.add_entry(SeekEntry { time: ts, pts: 0, pos });
1143         }
1144         idx.filled = true;
1145         seek_idx.mode = SeekIndexMode::Present;
1146         Ok(())
1147     }
1148 }
1149
1150 fn read_string_size(src: &mut ByteReader, size: usize) -> DemuxerResult<String> {
1151     let mut vec: Vec<u8> = Vec::new();
1152     for _ in 0..size {
1153         let c = src.read_byte()?;
1154         vec.push(c);
1155     }
1156     let str = String::from_utf8(vec);
1157     if str.is_ok() {
1158         Ok(str.unwrap())
1159     } else {
1160         Ok(String::new())
1161     }
1162 }
1163
1164 struct RealAudioDemuxer<'a> {
1165     src:            &'a mut ByteReader<'a>,
1166     stream:         Option<RMAudioStream>,
1167     data_start:     u64,
1168     data_end:       u64,
1169     blk_size:       usize,
1170     queued_pkts:    Vec<NAPacket>,
1171 }
1172
1173 impl<'a> DemuxCore<'a> for RealAudioDemuxer<'a> {
1174     #[allow(unused_variables)]
1175     fn open(&mut self, strmgr: &mut StreamManager, _seek_idx: &mut SeekIndex) -> DemuxerResult<()> {
1176         let magic                                       = self.src.read_u32be()?;
1177         validate!(magic == mktag!(b".ra\xFD"));
1178         let ver         = self.src.read_u16be()?;
1179         let ainfo = match ver {
1180             3 => {
1181                     parse_aformat3(&mut self.src)?
1182                 },
1183             4 => {
1184                     parse_aformat4(&mut self.src)?
1185                 },
1186             5 => {
1187                     parse_aformat5(&mut self.src)?
1188                 },
1189             _ => {
1190                     println!("unknown version {}", ver);
1191                     return Err(DemuxerError::InvalidData);
1192                 },
1193         };
1194 println!(" got ainfo {:?}", ainfo);
1195         let cname = find_codec_name(RM_AUDIO_CODEC_REGISTER, ainfo.fcc);
1196         let blk_size = if ainfo.fcc != mktag!(b"sipr") {
1197                 ainfo.granularity as usize
1198             } else {
1199                 validate!(ainfo.flavor <= 3);
1200                 RM_SIPRO_BLOCK_SIZES[ainfo.flavor as usize]
1201             };
1202         let srate = ainfo.sample_rate;
1203         let soniton = NASoniton::new(ainfo.sample_size as u8, SONITON_FLAG_SIGNED);
1204         let ahdr = NAAudioInfo::new(srate, ainfo.channels as u8, soniton, blk_size);
1205         let extradata = if ainfo.edata_size == 0 {
1206                 None
1207             } else {
1208                 let mut dta: Vec<u8> = vec![0; ainfo.edata_size as usize];
1209                 self.src.read_buf(dta.as_mut_slice())?;
1210                 Some(dta)
1211             };
1212         let nainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
1213         let res = strmgr.add_stream(NAStream::new(StreamType::Audio, 0, nainfo, 1, srate));
1214         if res.is_none() { return Err(MemoryError); }
1215
1216         let astr = RMAudioStream::new(ainfo.ileave_info);
1217         self.data_start = self.src.tell();
1218         self.data_end   = if ainfo.total_bytes > 0 { self.src.tell() + (ainfo.total_bytes as u64) } else { 0 };
1219         self.blk_size = blk_size;
1220         self.stream = Some(astr);
1221
1222         Ok(())
1223     }
1224
1225     fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
1226         if !self.queued_pkts.is_empty() {
1227             let pkt = self.queued_pkts.pop().unwrap();
1228             return Ok(pkt);
1229         }
1230         if (self.data_end != 0) && (self.src.tell() >= self.data_end) {
1231             return Err(DemuxerError::EOF);
1232         }
1233         let streamres = strmgr.get_stream_by_id(0);
1234         let stream = streamres.unwrap();
1235         if let Some(ref mut astr) = self.stream {
1236             loop {
1237                 let ret = astr.read_apackets(&mut self.queued_pkts, &mut self.src, stream.clone(), 0, false, self.blk_size);
1238                 if let Err(DemuxerError::TryAgain) = ret {
1239                     continue;
1240                 }
1241                 return ret;
1242             }
1243         }
1244         Err(DemuxerError::NoSuchInput)
1245     }
1246
1247     #[allow(unused_variables)]
1248     fn seek(&mut self, time: u64, seek_idx: &SeekIndex) -> DemuxerResult<()> {
1249         Err(NotImplemented)
1250     }
1251 }
1252
1253 impl<'a> RealAudioDemuxer<'a> {
1254     fn new(io: &'a mut ByteReader<'a>) -> Self {
1255         RealAudioDemuxer {
1256             src:            io,
1257             data_start:     0,
1258             data_end:       0,
1259             blk_size:       0,
1260             stream:         None,
1261             queued_pkts:    Vec::new(),
1262         }
1263     }
1264 }
1265
1266 enum IVRRecord {
1267     Invalid(u8),
1268     StreamProperties(usize),
1269     Packet { ts: u32, str: u32, flags: u32, len: usize, checksum: u32 },
1270     IntValue(Vec<u8>, u32),
1271     BinaryData(Vec<u8>, Vec<u8>),
1272     StringData(Vec<u8>, Vec<u8>),
1273     HeaderEnd,
1274     DataStart,
1275     DataEnd,
1276 }
1277
1278 impl IVRRecord {
1279     fn read_string(src: &mut ByteReader) -> DemuxerResult<Vec<u8>> {
1280         let len                     = src.read_u32be()? as usize;
1281         let mut val = vec![0; len];
1282         src.read_buf(val.as_mut_slice())?;
1283         Ok(val)
1284     }
1285
1286     fn read(src: &mut ByteReader) -> DemuxerResult<Self> {
1287         let code = src.read_byte()?;
1288         match code {
1289             1 => {
1290                     let val     = src.read_u32be()? as usize;
1291                     Ok(IVRRecord::StreamProperties(val))
1292                 },
1293             2 => {
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                     validate!((len > 0) && (len < (1 << 24)));
1300                     Ok(IVRRecord::Packet { ts, str, flags, len, checksum: chk })
1301                 },
1302             3 => {
1303                     let name = Self::read_string(src)?;
1304                     let len  = src.read_u32be()?;
1305                     validate!(len == 4);
1306                     let val  = src.read_u32be()?;
1307                     Ok(IVRRecord::IntValue(name, val))
1308                 },
1309             4 => {
1310                     let name = Self::read_string(src)?;
1311                     let len  = src.read_u32be()? as usize;
1312                     let mut val = vec![0; len];
1313                     src.read_buf(val.as_mut_slice())?;
1314                     Ok(IVRRecord::BinaryData(name, val))
1315                 },
1316             5 => {
1317                     let name = Self::read_string(src)?;
1318                     let val  = Self::read_string(src)?;
1319                     Ok(IVRRecord::StringData(name, val))
1320                 },
1321             6 => Ok(IVRRecord::HeaderEnd),
1322             7 => {
1323                     src.read_skip(8)?; // always zero?
1324                     Ok(IVRRecord::DataEnd)
1325                 },
1326             8 => {
1327                     src.read_skip(8)?; // always zero?
1328                     Ok(IVRRecord::DataStart)
1329                 },
1330             _ => Ok(IVRRecord::Invalid(code)),
1331         }
1332     }
1333     fn is_data_start(&self) -> bool {
1334         match *self {
1335             IVRRecord::DataStart => true,
1336             _ => false,
1337         }
1338     }
1339 }
1340
1341 impl fmt::Display for IVRRecord {
1342     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1343         match *self {
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"),
1358         }
1359     }
1360 }
1361
1362 struct RecordDemuxer {
1363     start_pos:      u64,
1364     cur_pos:        u64,
1365     start_str:      u32,
1366     remap_ids:      Vec<u32>,
1367 }
1368
1369 impl RecordDemuxer {
1370     fn new(pos: u64, start_str: u32) -> Self {
1371         RecordDemuxer {
1372             start_pos:      pos,
1373             cur_pos:        pos,
1374             start_str,
1375             remap_ids:      Vec::new(),
1376         }
1377     }
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);
1387         }
1388         let mut has_seek_table = false;
1389         let mut cur_str_no = 0;
1390         loop {
1391             let rec = IVRRecord::read(src)?;
1392             match rec {
1393                 IVRRecord::HeaderEnd => { break; },
1394                 IVRRecord::StreamProperties(num) => {
1395                         let stream_no = cur_str_no + self.start_str;
1396                         cur_str_no += 1;
1397                         let mut parsed = false;
1398                         let mut real_stream_no = 0;
1399                         for _ in 0..num {
1400                             let rec = IVRRecord::read(src)?;
1401 //println!("  strm property {}", rec);
1402                             match rec {
1403                                 IVRRecord::IntValue(ref name, val)   => {
1404                                         if name == b"StreamNumber\0" {
1405                                             real_stream_no = val;
1406                                         }
1407                                     },
1408                                 IVRRecord::BinaryData(ref name, ref val)   => {
1409                                         if name == b"OpaqueData\0" {
1410                                             validate!(!parsed);
1411                                             let is_mlti = RMDemuxCommon::parse_stream_info(str_data, strmgr, stream_no, val)?;
1412                                             if !is_mlti {
1413                                                 str_data.str_ids.push(stream_no);
1414                                             }
1415                                             parsed = true;
1416                                         }
1417                                     },
1418                                 IVRRecord::StringData(ref name, ref val)   => {
1419                                         if (name == b"SeekType\0") && (val != b"None\0") {
1420                                             has_seek_table = true;
1421                                         }
1422                                     },
1423                                 _ => { return Err(DemuxerError::InvalidData); }
1424                             };
1425                         }
1426                         if !parsed {
1427                             str_data.streams.push(RMStreamType::Unknown);
1428                             str_data.str_ids.push(stream_no);
1429                         }
1430                         self.remap_ids.push(real_stream_no);
1431                     },
1432                 _ => {println!(" unexpected {}", rec); return Err(DemuxerError::InvalidData); }
1433             };
1434         }
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);
1441         if has_seek_table {
1442             src.read_skip(4)?;
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());
1450         } else {
1451             let ntype = src.peek_byte()?;
1452             validate!((ntype == 2) || (ntype == 7)); // packet or data end, no start
1453         }
1454
1455         self.cur_pos = src.tell();
1456
1457         Ok(())
1458     }
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))?;
1461         loop {
1462             let rec = IVRRecord::read(src)?;
1463             match rec {
1464                 IVRRecord::Packet { ts, str, flags, len, .. } => {
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 pkt_grp = ((flags >> 8) & 0xFF) as u16;
1470                         let stream_id = str_data.get_stream_id(str_no as u32, pkt_grp);
1471                         let sr = str_data.find_stream(stream_id);
1472                         if sr.is_none() {
1473                             src.read_skip(payload_size)?;
1474                             return Err(DemuxerError::InvalidData);
1475                         }
1476                         let str_id = sr.unwrap();
1477
1478                         let streamres = strmgr.get_stream_by_id(stream_id);
1479                         if streamres.is_none() {
1480                             src.read_skip(payload_size)?;
1481                             continue;
1482                         }
1483                         let stream = streamres.unwrap();
1484                         if strmgr.is_ignored_id(stream_id) {
1485                             src.read_skip(payload_size)?;
1486                             continue;
1487                         }
1488                         let keyframe = false;
1489                         let ret = RMDemuxCommon::parse_packet_payload(src, &mut str_data.streams[str_id], stream, slice_buf, queued_pkts, keyframe, ts, payload_size);
1490                         if let Err(DemuxerError::TryAgain) = ret {
1491                             continue;
1492                         } else {
1493                             self.cur_pos = src.tell();
1494                             return ret;
1495                         }
1496                     },
1497                 IVRRecord::DataEnd      => return Err(DemuxerError::EOF),
1498                 _                       => return Err(DemuxerError::InvalidData),
1499             }
1500         }
1501     }
1502 }
1503
1504 struct RealIVRDemuxer<'a> {
1505     src:            &'a mut ByteReader<'a>,
1506     recs:           Vec<RecordDemuxer>,
1507     cur_rec:        usize,
1508     queued_pkts:    Vec<NAPacket>,
1509     slice_buf:      Vec<u8>,
1510     str_data:       CommonStreamData,
1511 }
1512
1513 impl<'a> DemuxCore<'a> for RealIVRDemuxer<'a> {
1514     #[allow(unused_variables)]
1515     fn open(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()> {
1516         let magic                                       = self.src.peek_u32be()?;
1517         if magic == mktag!(b".REC") {
1518             let mut rec = RecordDemuxer::new(0, 0);
1519             rec.parse_header(&mut self.src, strmgr, &mut self.str_data)?;
1520             self.recs.push(rec);
1521         } else if magic == mktag!(b".R1M") {
1522 println!("R1M kind");
1523             self.src.read_skip(4)?; // magic
1524             self.src.read_skip(3)?; // always 0, 1, 1 ?
1525             let _name = IVRRecord::read_string(&mut self.src)?;
1526             self.src.read_skip(1)?; // always 0?
1527             let len1 = self.src.read_u32be()? as u64;
1528             let off1 = self.src.read_u64be()?;
1529             let cpos = self.src.tell();
1530             validate!(off1 == len1 + cpos - 8);
1531             self.src.read_skip((off1 - cpos) as usize)?;
1532             loop {
1533                 let typ = self.src.read_byte()?;
1534                 println!(" at {:X} type {:02X}", self.src.tell(), typ);
1535                 match typ {
1536                     1 => {
1537                             let len = self.src.read_u32be()?;
1538                             self.src.read_skip(len as usize)?;
1539                         },
1540                     2 => {
1541                             let len = self.src.read_u32be()? as u64;
1542                             let pos = self.src.tell();
1543                             if len > 0x20 {
1544                                 let num_streams = self.str_data.streams.len() as u32;
1545                                 let mut rec = RecordDemuxer::new(pos + 12, num_streams);
1546                                 rec.parse_header(&mut self.src, strmgr, &mut self.str_data)?;
1547                                 self.recs.push(rec);
1548                             }
1549                             self.src.seek(SeekFrom::Start(pos + len))?;
1550                         },
1551                     b'R' => {
1552                             let mut buf: [u8; 2] = [0; 2];
1553                             self.src.peek_buf(&mut buf)?;
1554                             if (buf[0] == b'J') && (buf[1] == b'M') { // RJMx markers at the end of file
1555                                 break;
1556                             } else {
1557                                 return Err(DemuxerError::InvalidData);
1558                             }
1559                         },
1560                     _ => { return Err(DemuxerError::InvalidData); },
1561                 };
1562             }
1563         } else {
1564             return Err(DemuxerError::InvalidData);
1565         }
1566
1567         Ok(())
1568     }
1569
1570     fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
1571         if !self.queued_pkts.is_empty() {
1572             let pkt = self.queued_pkts.pop().unwrap();
1573             return Ok(pkt);
1574         }
1575         loop {
1576             if self.cur_rec >= self.recs.len() { return Err(DemuxerError::EOF); }
1577             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);
1578             if let Err(DemuxerError::EOF) = res {
1579                 self.cur_rec += 1;
1580             } else {
1581                 return res;
1582             }
1583         }
1584     }
1585
1586     #[allow(unused_variables)]
1587     fn seek(&mut self, time: u64, seek_idx: &SeekIndex) -> DemuxerResult<()> {
1588         Err(NotImplemented)
1589     }
1590 }
1591
1592 impl<'a> RealIVRDemuxer<'a> {
1593     fn new(io: &'a mut ByteReader<'a>) -> Self {
1594         RealIVRDemuxer {
1595             src:            io,
1596             recs:           Vec::new(),
1597             cur_rec:        0,
1598             queued_pkts:    Vec::new(),
1599             slice_buf:      Vec::new(),
1600             str_data:       CommonStreamData::new(),
1601         }
1602     }
1603 }
1604
1605 static RM_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
1606     (b"RV10", "realvideo1"),
1607     (b"RV20", "realvideo2"),
1608     (b"RVTR", "realvideo2"),
1609     (b"RV30", "realvideo3"),
1610     (b"RV40", "realvideo4"),
1611     (b"RV60", "realvideo6"),
1612     (b"CLV1", "clearvideo_rm"),
1613 ];
1614
1615 static RM_AUDIO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
1616     (b"lpcJ", "ra14.4"),
1617     (b"28_8", "ra28.8"),
1618     (b"cook", "cook"),
1619     (b"dnet", "ac3"),
1620     (b"sipr", "sipro"),
1621     (b"atrc", "atrac3"),
1622     (b"LSD:", "ralf"),
1623     (b"raac", "aac"),
1624     (b"racp", "aac"),
1625 ];
1626
1627 pub struct RealMediaDemuxerCreator { }
1628
1629 impl DemuxerCreator for RealMediaDemuxerCreator {
1630     fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
1631         Box::new(RealMediaDemuxer::new(br))
1632     }
1633     fn get_name(&self) -> &'static str { "realmedia" }
1634 }
1635
1636 pub struct RealAudioDemuxerCreator { }
1637
1638 impl DemuxerCreator for RealAudioDemuxerCreator {
1639     fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
1640         Box::new(RealAudioDemuxer::new(br))
1641     }
1642     fn get_name(&self) -> &'static str { "realaudio" }
1643 }
1644
1645 pub struct RealIVRDemuxerCreator { }
1646
1647 impl DemuxerCreator for RealIVRDemuxerCreator {
1648     fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
1649         Box::new(RealIVRDemuxer::new(br))
1650     }
1651     fn get_name(&self) -> &'static str { "real_ivr" }
1652 }
1653
1654 #[cfg(test)]
1655 mod test {
1656     use super::*;
1657     use std::fs::File;
1658
1659     #[test]
1660     fn test_rm_demux() {
1661         let mut file =
1662             File::open("assets/RV/rv10_dnet_640x352_realvideo_encoder_4.0.rm").unwrap();
1663 //            File::open("assets/RV/rv20_cook_640x352_realproducer_plus_8.51.rm").unwrap();
1664 //            File::open("assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm").unwrap();
1665 //            File::open("assets/RV/rv30_atrc_384x208_realproducer_plus_8.51.rm").unwrap();
1666 //            File::open("assets/RV/rv30_chroma_drift.rm").unwrap();
1667 //            File::open("assets/RV/rv30_weighted_mc.rm").unwrap();
1668 //            File::open("assets/RV/rv40_weighted_mc.rmvb").unwrap();
1669 //            File::open("assets/RV/rv40_weighted_mc_2.rmvb").unwrap();
1670 //            File::open("assets/RV/clv1_sipr_384x208_realvideo_encoder_4.0.rm").unwrap();
1671 //            File::open("assets/RV/luckynight.rmvb").unwrap();
1672 //            File::open("assets/RV/rv40_ralf.rmvb").unwrap();
1673         let mut fr = FileReader::new_read(&mut file);
1674         let mut br = ByteReader::new(&mut fr);
1675         let mut dmx = RealMediaDemuxer::new(&mut br);
1676         let mut sm = StreamManager::new();
1677         let mut si = SeekIndex::new();
1678         dmx.open(&mut sm, &mut si).unwrap();
1679
1680         loop {
1681             let pktres = dmx.get_frame(&mut sm);
1682             if let Err(e) = pktres {
1683                 if e == DemuxerError::EOF { break; }
1684                 panic!("error");
1685             }
1686             let pkt = pktres.unwrap();
1687             println!("Got {}", pkt);
1688         }
1689 //panic!("the end");
1690     }
1691     #[test]
1692     fn test_ra_demux() {
1693         let mut file =
1694 //            File::open("assets/RV/welcome288.ra").unwrap();
1695             File::open("assets/RV/diemusik.ra").unwrap();
1696         let mut fr = FileReader::new_read(&mut file);
1697         let mut br = ByteReader::new(&mut fr);
1698         let mut dmx = RealAudioDemuxer::new(&mut br);
1699         let mut sm = StreamManager::new();
1700         let mut si = SeekIndex::new();
1701         dmx.open(&mut sm, &mut si).unwrap();
1702
1703         loop {
1704             let pktres = dmx.get_frame(&mut sm);
1705             if let Err(e) = pktres {
1706                 if e == DemuxerError::EOF { break; }
1707                 panic!("error");
1708             }
1709             let pkt = pktres.unwrap();
1710             println!("Got {}", pkt);
1711         }
1712     }
1713     #[test]
1714     fn test_ivr_demux() {
1715         let mut file =
1716             File::open("assets/RV/Opener_rm_hi.ivr").unwrap();
1717 //            File::open("assets/RV/SherwinWilliamsCommercial.ivr").unwrap();
1718         let mut fr = FileReader::new_read(&mut file);
1719         let mut br = ByteReader::new(&mut fr);
1720         let mut dmx = RealIVRDemuxer::new(&mut br);
1721         let mut sm = StreamManager::new();
1722         let mut si = SeekIndex::new();
1723         dmx.open(&mut sm, &mut si).unwrap();
1724
1725         loop {
1726             let pktres = dmx.get_frame(&mut sm);
1727             if let Err(e) = pktres {
1728                 if e == DemuxerError::EOF { break; }
1729                 panic!("error");
1730             }
1731             let pkt = pktres.unwrap();
1732             println!("Got {}", pkt);
1733         }
1734     }
1735 }