]> git.nihav.org Git - nihav.git/blob - nihav-realmedia/src/demuxers/realmedia.rs
projects / nihav.git / blob
? search:


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