projects / nihav.git / blob
? search:


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