projects / nihav.git / blob
? search:


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