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