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