projects / nihav.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
rmdec: Sipro deinterleaver
[nihav.git] / src / demuxers / realmedia.rs
CommitLineData
ce52b3b5
KS		 1use super::*;
2use super::DemuxerError::*;
3//use io::byteio::*;
4//use frame::*;
5use formats::*;
6use std::io::SeekFrom;
7use std::mem;
8
9macro_rules! mktag {
10 ($a:expr, $b:expr, $c:expr, $d:expr) => ({
11 (($a as u32) << 24) | (($b as u32) << 16) | (($c as u32) << 8) | ($d as u32)
12 });
13 ($arr:expr) => ({
14 (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
15 });
16}
17
02cb1e03
KS		 18const RM_SIPRO_BLOCK_SIZES: [usize; 4] = [ 29, 19, 37, 20 ];
19const RM_SIPRO_SWAPS: [[u8; 2]; 38] = [
20 [ 0, 63 ], [ 1, 22 ], [ 2, 44 ], [ 3, 90 ],
21 [ 5, 81 ], [ 7, 31 ], [ 8, 86 ], [ 9, 58 ],
22 [ 10, 36 ], [ 12, 68 ], [ 13, 39 ], [ 14, 73 ],
23 [ 15, 53 ], [ 16, 69 ], [ 17, 57 ], [ 19, 88 ],
24 [ 20, 34 ], [ 21, 71 ], [ 24, 46 ], [ 25, 94 ],
25 [ 26, 54 ], [ 28, 75 ], [ 29, 50 ], [ 32, 70 ],
26 [ 33, 92 ], [ 35, 74 ], [ 38, 85 ], [ 40, 56 ],
27 [ 42, 87 ], [ 43, 65 ], [ 45, 59 ], [ 48, 79 ],
28 [ 49, 93 ], [ 51, 89 ], [ 55, 95 ], [ 61, 76 ],
29 [ 67, 83 ], [ 77, 80 ]
30];
31
ce52b3b5
KS		 32struct RMVideoStream {
33 frame: Vec<u8>,
34 hdr_size: usize,
35 frame_size: usize,
36 frame_pos: usize,
37}
38
39impl RMVideoStream {
40 fn new() -> Self {
41 RMVideoStream {
42 frame: Vec::new(),
43 hdr_size: 0,
44 frame_size: 0,
45 frame_pos: 0,
46 }
47 }
48 fn flush(&mut self) {
49 self.frame.truncate(0);
50 self.frame_size = 0;
51 self.frame_pos = 0;
52 }
53 fn start_slice(&mut self, num_slices: usize, frame_size: usize, data: &[u8]) {
54 self.hdr_size = num_slices * 8 + 1;
55 self.frame.resize(frame_size + self.hdr_size, 0);
56 self.frame[0] = (num_slices - 1) as u8;
57 self.frame_pos = 0;
58 self.add_slice(1, data);
59 }
60 fn add_slice(&mut self, slice_no: usize, data: &[u8]) {
61 self.write_slice_info(slice_no);
9037cf6b 62 let dslice = &mut self.frame[self.hdr_size + self.frame_pos..][..data.len()];
ce52b3b5
KS		 63 dslice.copy_from_slice(data);
64 self.frame_pos += data.len();
65 }
66 fn write_slice_info(&mut self, slice_no: usize) {
67 let off = 1 + (slice_no - 1) * 8;
68 self.frame[off + 0] = 0;
69 self.frame[off + 1] = 0;
70 self.frame[off + 2] = 0;
71 self.frame[off + 3] = 1;
72 self.frame[off + 4] = (self.frame_pos >> 24) as u8;
73 self.frame[off + 5] = (self.frame_pos >> 16) as u8;
74 self.frame[off + 6] = (self.frame_pos >> 8) as u8;
75 self.frame[off + 7] = (self.frame_pos >> 0) as u8;
76 }
77 fn get_frame_data(&mut self) -> Vec<u8> {
78 let mut v: Vec<u8> = Vec::new();
79 mem::swap(&mut v, &mut self.frame);
80 self.flush();
81 v
82 }
83}
84
b1ef37ee 85#[allow(dead_code)]
ce52b3b5
KS		 86#[derive(Clone,Copy,PartialEq)]
87enum Deinterleaver {
88 None,
c19ce782 89 RA28_8,
ce52b3b5
KS		 90 Generic,
91 Sipro,
92 VBR,
93}
94
b1ef37ee 95#[allow(dead_code)]
ce52b3b5
KS		 96struct RMAudioStream {
97 deint: Deinterleaver,
c19ce782 98 iinfo: Option<InterleaveInfo>,
fe07b469
KS		 99 buf: Vec<u8>,
100 sub_packet: usize,
ce52b3b5
KS		 101}
102
c19ce782
KS		 103const RM_ILEAVE_INT0: u32 = mktag!(b"Int0");
104const RM_ILEAVE_INT4: u32 = mktag!(b"Int4");
105const RM_ILEAVE_GENR: u32 = mktag!(b"genr");
106const RM_ILEAVE_SIPR: u32 = mktag!(b"sipr");
107const RM_ILEAVE_VBRS: u32 = mktag!(b"vbrs");
108
ce52b3b5 109impl RMAudioStream {
c19ce782
KS		 110 fn new(iinfo: Option<InterleaveInfo>) -> Self {
111 let deint;
fe07b469 112 let mut buf: Vec<u8>;
c19ce782
KS		 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_VBRS => Deinterleaver::VBR,
120 _ => {println!("unknown deint {:X}", info.id); Deinterleaver::None },
121 };
fe07b469
KS		 122 match deint {
123 Deinterleaver::None => { buf = Vec::new(); },
6669c73b
KS		 124 Deinterleaver::RA28_8 |
125 Deinterleaver::Generic |
126 Deinterleaver::Sipro => {
fe07b469
KS		 127 let bsize = (info.frame_size as usize) * (info.factor as usize);
128 buf = Vec::with_capacity(bsize);
129 buf.resize(bsize, 0u8);
130 },
fe07b469
KS		 131 Deinterleaver::VBR => { unimplemented!("deint"); },
132 };
c19ce782
KS		 133 } else {
134 deint = Deinterleaver::None;
fe07b469
KS		 135 buf = Vec::new();
136 }
137 RMAudioStream { deint: deint, iinfo: iinfo, buf: buf, sub_packet: 0 }
138 }
6669c73b 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> {
fe07b469
KS		 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 {
6669c73b 147 Deinterleaver::None => { return src.read_packet(stream, ts, keyframe, payload_size); },
fe07b469
KS		 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;
6669c73b 162 return Ok(NAPacket::new(stream, ts, true, self.buf.clone()));
fe07b469 163 } else {
6669c73b 164 return Err(DemuxerError::TryAgain);
fe07b469
KS		 165 }
166 },
6669c73b
KS		 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 _ => { return src.read_packet(stream, ts, keyframe, payload_size); },
190 };
191
192 let iinfo = self.iinfo.unwrap();
193 let factor = iinfo.factor as usize;
194 let fsize = iinfo.frame_size as usize;
195
196 self.sub_packet += 1;
197 if self.sub_packet < factor {
198 return Err(DemuxerError::TryAgain);
199 }
200
201 self.sub_packet = 0;
202
203 if self.deint == Deinterleaver::Sipro {
02cb1e03 204 sipro_restore(&mut self.buf, factor, fsize);
6669c73b
KS		 205 }
206
207 let mut frames_iter = self.buf.chunks(fsize);
208 let pkt0 = frames_iter.next().unwrap();
209
210 let pkt_ts = NATimeInfo::new(None, None, None, tb_num, tb_den);
211 for pkts in frames_iter {
212 let pkt = NAPacket::new(stream.clone(), pkt_ts, true, pkts.to_vec());
213 queued_packets.push(pkt);
c19ce782 214 }
6669c73b
KS		 215 queued_packets.reverse();
216 Ok(NAPacket::new(stream, ts, true, pkt0.to_vec()))
ce52b3b5
KS		 217 }
218}
219
02cb1e03
KS		 220fn sipro_restore(buf: &mut [u8], factor: usize, fsize: usize) {
221 let stride = factor * fsize * 2 / 96;
222 for i in 0..38 {
223 let mut sidx = (RM_SIPRO_SWAPS[i][0] as usize) * stride;
224 let mut didx = (RM_SIPRO_SWAPS[i][1] as usize) * stride;
225 for _ in 0..stride {
226 let in0 = buf[sidx >> 1];
227 let in1 = buf[didx >> 1];
228 let nib0 = (in0 >> ((sidx & 1) * 4)) & 0xF;
229 let nib1 = (in1 >> ((didx & 1) * 4)) & 0xF;
230
231 buf[didx >> 1] = (nib0 << (4 * (didx & 1))) | (in1 & (0xF << (4 * (!didx & 1))));
232 buf[sidx >> 1] = (nib1 << (4 * (sidx & 1))) | (in0 & (0xF << (4 * (!sidx & 1))));
233
234 sidx += 1;
235 didx += 1;
236 }
237 }
238}
239
ce52b3b5
KS		 240enum RMStreamType {
241 Audio(RMAudioStream),
242 Video(RMVideoStream),
243 Logical,
244 Unknown,
245}
246
247struct RealMediaDemuxer<'a> {
248 src: &'a mut ByteReader<'a>,
249 data_pos: u64,
250 num_packets: u32,
251 cur_packet: u32,
252
253 streams: Vec<RMStreamType>,
254 str_ids: Vec<u16>,
255
256 queued_pkts: Vec<NAPacket>,
257 slice_buf: Vec<u8>,
258}
259
260fn find_codec_name(registry: &[(&[u8;4], &'static str)], fcc: u32) -> &'static str {
261 for &(fourcc, name) in registry {
262 if mktag!(fourcc) == fcc { return name; }
263 }
264 "unknown"
265}
266
267fn read_14or30(src: &mut ByteReader) -> DemuxerResult<(bool, u32)> {
268 let tmp = src.read_u16be()?;
269 let flag = (tmp & 0x8000) != 0;
270 if (tmp & 0x4000) == 0x4000 {
271 Ok((flag, ((tmp & 0x3FFF) as u32)))
272 } else {
273 let val = ((tmp as u32) << 16) | (src.read_u16be()? as u32);
274 Ok((flag, val & 0x3FFFFFFF))
275 }
276}
277
278fn read_video_buf(src: &mut ByteReader, stream: Rc<NAStream>, ts: u32, keyframe: bool, frame_size: usize) -> DemuxerResult<NAPacket> {
279 let size = (frame_size as usize) + 9;
280 let mut vec: Vec<u8> = Vec::with_capacity(size);
281 vec.resize(size, 0);
282 //v[0] = 0; // 1 slice
283 vec[4] = 1;
284 src.read_buf(&mut vec[9..])?;
285
286 let (tb_num, tb_den) = stream.get_timebase();
287 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
288 Ok(NAPacket::new(stream, ts, keyframe, vec))
289}
290
291fn read_multiple_frame(src: &mut ByteReader, stream: Rc<NAStream>, keyframe: bool, skip_mtype: bool) -> DemuxerResult<NAPacket> {
292 if !skip_mtype {
293 let mtype = src.read_byte()?;
294 validate!(mtype == 0xC0);
295 }
296 let (_, frame_size) = read_14or30(src)?;
297 let (_, timestamp) = read_14or30(src)?;
c9aba47e
KS		 298 let _seq_no = src.read_byte()?;
299//println!(" multiple frame size {} ts {} seq {}", frame_size, timestamp, seq_no);
ce52b3b5
KS		 300
301 read_video_buf(src, stream, timestamp, keyframe, frame_size as usize)
302}
303
304impl<'a> DemuxCore<'a> for RealMediaDemuxer<'a> {
305 #[allow(unused_variables)]
306 fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
307 self.read_header(strmgr)?;
308 Ok(())
309 }
310
311#[allow(unused_variables)]
312 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
313 if !self.queued_pkts.is_empty() {
314 let pkt = self.queued_pkts.pop().unwrap();
315 return Ok(pkt);
316 }
317 loop {
318 if self.cur_packet >= self.num_packets { return Err(DemuxerError::EOF); }
319
320 let pkt_start = self.src.tell();
321 let ver = self.src.read_u16le()?;
322 validate!(ver <= 1);
323 let len = self.src.read_u16be()? as usize;
324 let str_no = self.src.read_u16be()?;
325 let ts = self.src.read_u32be()?;
c9aba47e 326 let _pkt_grp;
ce52b3b5 327 if ver == 0 {
c9aba47e 328 _pkt_grp = self.src.read_byte()?;
ce52b3b5
KS		 329 } else {
330 //asm_rule = self.src.read_u16le()?;
331 self.src.read_skip(2)?;
c9aba47e 332 _pkt_grp = 0;
ce52b3b5
KS		 333 }
334 let flags = self.src.read_byte()?;
335 let hdr_size = self.src.tell() - pkt_start;
9f45e528 336//println!("packet @{:X} size {} for {} ts {} grp {} flags {:X}", pkt_start, len, str_no, ts, _pkt_grp, flags);
ce52b3b5
KS		 337 self.cur_packet += 1;
338
339 let payload_size = len - (hdr_size as usize);
340
341 let sr = self.str_ids.iter().position(|x| *x == str_no);
342 if sr.is_none() {
c9aba47e 343//println!("stream {} not found", str_no);
ce52b3b5
KS		 344 self.src.read_skip(payload_size)?;
345 return Err(DemuxerError::InvalidData);
346 }
347 let str_id = sr.unwrap();
c9aba47e
KS		 348 let streamres = strmgr.get_stream_by_id(str_no as u32);
349 if streamres.is_none() {
350 self.src.read_skip(payload_size)?;
351 continue;
352 }
353 let stream = streamres.unwrap();
354//println!(" stream {}", str_id);
ce52b3b5
KS		 355 if strmgr.is_ignored_id(str_no as u32) {
356 self.src.read_skip(payload_size)?;
357 continue;
358 }
359 //todo skip unwanted packet
360 let keyframe = (flags & KEYFRAME_FLAG) != 0;
361
362 let result = match self.streams[str_id] {
363 RMStreamType::Video(ref mut vstr) => {
364
365 let pos = self.src.tell();
366 let b0 = self.src.read_byte()?;
367 match b0 >> 6 {
368 0 => { // partial frame
369 let b1 = self.src.read_byte()?;
370 let hdr1 = ((b0 as u16) << 8) | (b1 as u16);
371 let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
372 let packet_num = hdr1 & 0x7F;
373 let (_, frame_size) = read_14or30(self.src)?;
374 let (_, off) = read_14or30(self.src)?;
375 let seq_no = self.src.read_byte()?;
c9aba47e 376//println!(" mode 0 pkt {}/{} off {}/{} seq {}", packet_num, num_pkts, off, frame_size, seq_no);
ce52b3b5
KS		 377 let hdr_skip = (self.src.tell() - pos) as usize;
378
379 let slice_size = (payload_size - hdr_skip) as usize;
380 self.slice_buf.resize(slice_size, 0);
381 self.src.read_buf(self.slice_buf.as_mut_slice())?;
382 if packet_num == 1 {
383 vstr.start_slice(num_pkts, frame_size as usize, self.slice_buf.as_slice());
384 } else {
385 vstr.add_slice(packet_num as usize, self.slice_buf.as_slice());
386 }
8a5cb596
KS		 387 if (packet_num as usize) < num_pkts {
388 continue;
389 }
390 //todo: check if full frame is received
391 let (tb_num, tb_den) = stream.get_timebase();
392 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
393 let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
394 Ok(pkt)
ce52b3b5
KS		 395 },
396 1 => { // whole frame
397 let seq_no = self.src.read_byte()?;
c9aba47e 398//println!(" mode 1 seq {}", seq_no);
ce52b3b5
KS		 399 read_video_buf(self.src, stream, ts, keyframe, payload_size - 1)
400 },
401 2 => { // last partial frame
402 let b1 = self.src.read_byte()?;
403 let hdr1 = ((b0 as u16) << 8) | (b1 as u16);
404 let num_pkts = ((hdr1 >> 7) & 0x7F) as usize;
405 let packet_num = hdr1 & 0x7F;
406 let (_, frame_size) = read_14or30(self.src)?;
407 let (_, tail_size) = read_14or30(self.src)?;
408 let seq_no = self.src.read_byte()?;
c9aba47e 409//println!(" mode 2 pkt {}/{} tail {}/{} seq {}", packet_num, num_pkts, tail_size, frame_size, seq_no);
ce52b3b5
KS		 410 self.slice_buf.resize(tail_size as usize, 0);
411 self.src.read_buf(self.slice_buf.as_mut_slice())?;
5b744f82
KS		 412 if packet_num == 1 && frame_size == tail_size {
413 vstr.start_slice(num_pkts, frame_size as usize, self.slice_buf.as_slice());
414 } else {
415 vstr.add_slice(packet_num as usize, self.slice_buf.as_slice());
416 }
ce52b3b5
KS		 417
418 while self.src.tell() < pos + (payload_size as u64) {
419 let res = read_multiple_frame(self.src, stream.clone(), false, false);
420 if res.is_err() { break; }
421 self.queued_pkts.push(res.unwrap());
422 }
423 self.queued_pkts.reverse();
424 let (tb_num, tb_den) = stream.get_timebase();
425 let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
426 let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
427 Ok(pkt)
428 },
429 _ => { // multiple frames
c9aba47e 430//println!(" mode 3");
ce52b3b5
KS		 431 let res = read_multiple_frame(self.src, stream.clone(), keyframe, true);
432 if res.is_err() { return res; }
433 while self.src.tell() < pos + (payload_size as u64) {
434 let res = read_multiple_frame(self.src, stream.clone(), false, false);
435 if res.is_err() { break; }
436 self.queued_pkts.push(res.unwrap());
437 }
438 self.queued_pkts.reverse();
439 res
440 },
441 }
442 },
443 RMStreamType::Audio(ref mut astr) => {
fe07b469
KS		 444 let ret = astr.read_apackets(&mut self.queued_pkts, &mut self.src, stream, ts, keyframe, payload_size);
445 if let Err(DemuxerError::TryAgain) = ret {
446 continue;
447 }
448 ret
ce52b3b5
KS		 449 },
450 _ => {
451// self.src.read_skip(payload_size)?;
452 Err(DemuxerError::InvalidData)
453 },
454 };
455 return result;
456 }
457 }
458
459 #[allow(unused_variables)]
460 fn seek(&mut self, time: u64) -> DemuxerResult<()> {
461 Err(NotImplemented)
462 }
463}
464
465fn read_chunk(src: &mut ByteReader) -> DemuxerResult<(u32, u32, u16)> {
466 let id = src.read_u32be()?;
6132225f 467if id == 0 { return Ok((0, 0, 0)); }
ce52b3b5 468 let size = src.read_u32be()?;
9f45e528
KS		 469if size == 0 {
470 let ver = src.read_u16be()?;
471 validate!(ver <= 1);
472 return Ok((id, 0x0FFFFFFF, ver));
473}
ce52b3b5
KS		 474 validate!(size >= 10);
475 let ver = src.read_u16be()?;
476 validate!(ver <= 1);
477 Ok((id, size, ver))
478}
479
c19ce782
KS		 480#[derive(Clone,Copy,Debug)]
481struct InterleaveInfo {
482 id: u32,
483 factor: u16,
484 block_size: u16,
485 frame_size: u16,
486}
487
488#[derive(Clone,Copy,Debug)]
489struct RealAudioInfo {
490 fcc: u32,
491 sample_rate: u32,
492 sample_size: u16,
02cb1e03 493 flavor: u16,
c19ce782
KS		 494 channels: u16,
495 channel_mask: u32,
496 granularity: u32,
497 bytes_per_minute: u32,
498 total_bytes: u32,
499 edata_size: u32,
500 ileave_info: Option<InterleaveInfo>
501}
502
503fn skip_ra_metadata(src: &mut ByteReader) -> DemuxerResult<()> {
504 let title_len = src.read_byte()? as usize;
505 src.read_skip(title_len)?;
506 let author_len = src.read_byte()? as usize;
507 src.read_skip(author_len)?;
508 let copywrong_len = src.read_byte()? as usize;
509 src.read_skip(copywrong_len)?;
510 let comment_len = src.read_byte()? as usize;
511 src.read_skip(comment_len)?;
512 Ok(())
513}
514
515#[allow(unused_variables)]
516fn parse_aformat3(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
517 let start = src.tell();
518 let header_len = src.read_u16be()?;
519 validate!(header_len >= 24);
520 let flavor = src.read_u16be()?;
521 let granularity = src.read_u32be()?;
522 let bytes_per_minute = src.read_u32be()?;
523 let total_bytes = src.read_u32be()?;
524
525 skip_ra_metadata(src)?;
526
527 let _can_copy = src.read_byte()?;
528 let fcc_len = src.read_byte()?;
529 validate!(fcc_len == 4);
530 let fcc = src.read_u32be()?;
531
532 let end = src.tell();
533 validate!(end - start <= (header_len as u64) + 2);
534
535 Ok(RealAudioInfo {
02cb1e03
KS		 536 fcc: fcc, flavor: flavor,
537 sample_rate: 8000, sample_size: 16, channels: 1, channel_mask: 0,
c19ce782
KS		 538 granularity: granularity, bytes_per_minute: bytes_per_minute,
539 total_bytes: total_bytes, edata_size: 0,
540 ileave_info: None,
541 })
542}
543
544#[allow(unused_variables)]
545fn parse_aformat4(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
546 let start = src.tell();
547 src.read_skip(2)?; // zeroes
548 let id = src.read_u32be()?;
549 validate!(id == mktag!(b".ra4"));
550 let data_size = src.read_u32be()?;
551 let _ver4 = src.read_u16be()?; // should be 4
552 let header_size = src.read_u32be()?;
02cb1e03 553 let flavor = src.read_u16be()?;
c19ce782
KS		 554 let granularity = src.read_u32be()?;
555 let total_bytes = src.read_u32be()?;
556 let bytes_per_minute = src.read_u32be()?;
557 let _bytes_per_minute2 = src.read_u32be()?;
558 let ileave_factor = src.read_u16be()?;
559 let ileave_block_size = src.read_u16be()?;
560 let _user_data = src.read_u16be()?;
561 let sample_rate = src.read_u32be()?;
562 let sample_size = src.read_u32be()?;
563 let channels = src.read_u16be()?;
564 let interleaver_id_len = src.read_byte()?;
565 validate!(interleaver_id_len == 4);
566 let interleaver_id = src.read_u32be()?;
567 let fcc_len = src.read_byte()?;
568 validate!(fcc_len == 4);
569 let fcc = src.read_u32be()?;
570 let is_interleaved = src.read_byte()?;
571 let _can_copy = src.read_byte()?;
572 let _stream_type = src.read_byte()?;
573
574 skip_ra_metadata(src)?;
575
576 let end = src.tell();
577 validate!(end - start <= (header_size as u64) + 10);
578
579 let ileave_info = if is_interleaved != 0 {
580 Some(InterleaveInfo {
fe07b469
KS		 581 id: interleaver_id, factor: ileave_factor, block_size: granularity as u16,
582 frame_size: ileave_block_size,
c19ce782
KS		 583 })
584 } else {
585 None
586 };
587
588 Ok(RealAudioInfo {
02cb1e03
KS		 589 fcc: fcc, flavor: flavor,
590 sample_rate: sample_rate, sample_size: sample_size as u16, channels: channels, channel_mask: 0,
c19ce782
KS		 591 granularity: granularity, bytes_per_minute: bytes_per_minute,
592 total_bytes: total_bytes & 0xFFFFFF, edata_size: 0,
593 ileave_info: ileave_info,
594 })
595}
596
597#[allow(unused_variables)]
598fn parse_aformat5(src: &mut ByteReader) -> DemuxerResult<RealAudioInfo> {
599 let start = src.tell();
600 src.read_skip(2)?; // zeroes
601 let id = src.read_u32be()?;
602 validate!(id == mktag!(b".ra5"));
603 let data_size = src.read_u32be()?;
604 let _ver5 = src.read_u16be()?; // should be 5
605 let header_size = src.read_u32be()?;
02cb1e03 606 let flavor = src.read_u16be()?;
c19ce782
KS		 607 let granularity = src.read_u32be()?;
608 let total_bytes = src.read_u32be()?;
609 let bytes_per_minute = src.read_u32be()?;
610 let _bytes_per_minute2 = src.read_u32be()?;
611 let ileave_factor = src.read_u16be()?;
c19ce782 612 let frame_size = src.read_u16be()?;
6669c73b 613 let ileave_block_size = src.read_u16be()?;
c19ce782
KS		 614 let user_data = src.read_u32be()?;
615 let _sample_rate1 = src.read_u16be()?;
616 let sample_rate = src.read_u32be()?;
617 let sample_size = src.read_u32be()?;
618 let channels = src.read_u16be()?;
619 let interleaver_id = src.read_u32be()?;
620 let fcc = src.read_u32be()?;
621 let is_interleaved = src.read_byte()?;
622 let _can_copy = src.read_byte()?;
623 let _stream_type = src.read_byte()?;
624 let has_ileave_pattern = src.read_byte()?;
625 if has_ileave_pattern != 0 {
626unimplemented!("ra5 interleave pattern");
627 }
628 let edata_size = src.read_u32be()?;
629
630 let end = src.tell();
631 validate!(end - start <= (header_size as u64) + 10);
632 src.read_skip((end as usize) - (header_size as usize))?;
633
634 let ileave_info = if is_interleaved != 0 {
635 Some(InterleaveInfo {
636 id: interleaver_id, factor: ileave_factor, block_size: ileave_block_size, frame_size: frame_size,
637 })
638 } else {
639 None
640 };
641
642 Ok(RealAudioInfo {
02cb1e03
KS		 643 fcc: fcc, flavor: flavor,
644 sample_rate: sample_rate, sample_size: sample_size as u16, channels: channels, channel_mask: 0,
c19ce782
KS		 645 granularity: granularity, bytes_per_minute: bytes_per_minute,
646 total_bytes: total_bytes & 0xFFFFFF, edata_size: edata_size,
647 ileave_info: ileave_info,
648 })
649}
650
ce52b3b5
KS		 651const RMVB_HDR_SIZE: u32 = 18;
652const RMVB_PROP_SIZE: u32 = 50;
653const KEYFRAME_FLAG: u8 = 0x02;
654
655impl<'a> RealMediaDemuxer<'a> {
656 fn new(io: &'a mut ByteReader<'a>) -> Self {
657 RealMediaDemuxer {
658 src: io,
659 data_pos: 0,
660 num_packets: 0,
661 cur_packet: 0,
662 streams: Vec::new(),
663 str_ids: Vec::new(),
664 queued_pkts: Vec::new(),
665 slice_buf: Vec::new(),
666 }
667 }
668#[allow(unused_variables)]
669 fn read_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
670 let (id, size, ver) = read_chunk(self.src)?;
671 validate!(id == mktag!(b".RMF"));
672 validate!(size >= RMVB_HDR_SIZE);
673 let fver = self.src.read_u32be()?;
674 validate!(fver <= 1);
675 let num_hdr = self.src.read_u32be()? as usize;
676 validate!(num_hdr >= 1);
677 if size > RMVB_HDR_SIZE {
678 self.src.read_skip((size - RMVB_HDR_SIZE) as usize)?;
679 }
680
681 let (id, size, ver) = read_chunk(self.src)?;
682 validate!(size >= RMVB_PROP_SIZE);
683 validate!(ver == 0);
684 let maxbr = self.src.read_u32be()?;
685 let avgbr = self.src.read_u32be()?;
686 let maxps = self.src.read_u32be()?;
687 let avgps = self.src.read_u32be()?;
688 let num_pkt = self.src.read_u32be()? as usize;
689 let duration = self.src.read_u32be()?;
690 let preroll = self.src.read_u32be()?;
691 let idx_off = self.src.read_u32be()?;
692 let data_off = self.src.read_u32be()?;
693 let num_streams = self.src.read_u16be()? as usize;
694 let flags = self.src.read_u16be()?;
695 if size > RMVB_PROP_SIZE {
696 self.src.read_skip((size - RMVB_PROP_SIZE) as usize)?;
697 }
698
699 for _ in 0..num_hdr {
c9aba47e
KS		 700 if self.src.is_eof() {
701 //warn maybe?
702 break;
703 }
704 let res = self.parse_chunk(strmgr);
705 match res {
706 Ok(last) => { if last { break; } },
707 Err(DemuxerError::IOError) => { break; },
708 Err(etype) => { return Err(etype); },
709 };
ce52b3b5 710 }
c9aba47e 711//println!("now @ {:X} / {}", self.src.tell(), self.data_pos);
ce52b3b5
KS		 712 validate!(self.data_pos > 0);
713 self.src.seek(SeekFrom::Start(self.data_pos))?;
714 let num_packets = self.src.read_u32be()?;
715 let next_data_hdr = self.src.read_u32be()?;
9f45e528 716 self.num_packets = if num_packets > 0 { num_packets } else { 0xFFFFFF };
ce52b3b5
KS		 717 self.cur_packet = 0;
718 Ok(())
719 }
6132225f 720 fn parse_chunk(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<bool> {
ce52b3b5
KS		 721 let (id, size, ver) = read_chunk(self.src)?;
722 let end_pos = self.src.tell() - 10 + (size as u64);
723
724 validate!(ver == 0);
725 if id == mktag!(b"CONT") { self.parse_content_desc()?; }
726 else if id == mktag!(b"MDPR") { self.parse_mdpr(strmgr)?; }
727 else if id == mktag!(b"DATA") { if self.data_pos == 0 { self.data_pos = self.src.tell(); } }
728 else if id == mktag!(b"INDX") { /* do nothing for now */ }
6132225f 729 else if id == 0 { return Ok(true); }
ce52b3b5
KS		 730 else { println!("unknown chunk type {:08X}", id); }
731
732 let cpos = self.src.tell();
733 if cpos < end_pos {
734 self.src.read_skip((end_pos - cpos) as usize)?;
735 }
6132225f 736 Ok(false)
ce52b3b5
KS		 737 }
738#[allow(unused_variables)]
739 fn parse_content_desc(&mut self) -> DemuxerResult<()> {
740 let title_len = self.src.read_u16be()? as usize;
741 self.src.read_skip(title_len)?;
742 let author_len = self.src.read_u16be()? as usize;
743 self.src.read_skip(author_len)?;
744 let copywrong_len = self.src.read_u16be()? as usize;
745 self.src.read_skip(copywrong_len)?;
746 let comment_len = self.src.read_u16be()? as usize;
747 self.src.read_skip(comment_len)?;
748 Ok(())
749 }
750#[allow(unused_variables)]
751 fn parse_mdpr(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
752 let stream_no = self.src.read_u16be()?;
753//todo check stream_no for duplicates
754 let maxbr = self.src.read_u32be()?;
755 let avgbr = self.src.read_u32be()?;
756 let maxps = self.src.read_u32be()?;
757 let avgps = self.src.read_u32be()?;
758 let start = self.src.read_u32be()?;
759 let preroll = self.src.read_u32be()?;
760 let duration = self.src.read_u32be()?;
761 let sname_size = self.src.read_byte()? as usize;
762 let sname = read_string_size(self.src, sname_size)?;
c9aba47e 763//println!("str #{} sname = {} pkts {}/{} start {} preroll {}", stream_no, sname, maxps, avgps, start, preroll);
ce52b3b5
KS		 764 let mime_size = self.src.read_byte()? as usize;
765 let mime = read_string_size(self.src, mime_size)?;
c9aba47e 766//println!("mime = {}", mime);
ce52b3b5
KS		 767 let edata_size = self.src.read_u32be()? as usize;
768 let edata: Option<Vec<u8>> = if edata_size == 0 { None } else {
769 let mut edvec: Vec<u8> = Vec::with_capacity(edata_size);
770 edvec.resize(edata_size, 0);
771 self.src.read_buf(&mut edvec)?;
772 Some(edvec)
773 };
774 self.str_ids.push(stream_no);
775 if edata_size > 8 {
776 if let Some(edata_) = edata {
777 let mut mr = MemoryReader::new_read(edata_.as_slice());
778 let mut src = ByteReader::new(&mut mr);
779
780 let tag = src.read_u32be()?;
781 let tag2 = src.peek_u32be()?;
c9aba47e 782//println!("tag1 {:X} tag2 {:X}", tag, tag2);
ce52b3b5 783 if tag == mktag!('.', 'r', 'a', 0xFD) {
c19ce782
KS		 784 let ver = src.read_u16be()?;
785 let ainfo = match ver {
786 3 => {
787 parse_aformat3(&mut src)?
788 },
789 4 => {
790 parse_aformat4(&mut src)?
791 },
792 5 => {
793 parse_aformat5(&mut src)?
794 },
795 _ => {
796 println!("unknown version {}", ver);
797 return Err(DemuxerError::InvalidData);
798 },
799 };
800println!(" got ainfo {:?}", ainfo);
801 let cname = find_codec_name(RM_AUDIO_CODEC_REGISTER, ainfo.fcc);
02cb1e03
KS		 802 let blk_size = if ainfo.fcc != mktag!(b"sipr") {
803 ainfo.granularity as usize
804 } else {
805 validate!(ainfo.flavor <= 3);
806 RM_SIPRO_BLOCK_SIZES[ainfo.flavor as usize]
807 };
c19ce782
KS		 808 let srate = ainfo.sample_rate;
809 let soniton = NASoniton::new(ainfo.sample_size as u8, SONITON_FLAG_SIGNED);
02cb1e03 810 let ahdr = NAAudioInfo::new(srate, ainfo.channels as u8, soniton, blk_size);
c19ce782
KS		 811 let extradata = if ainfo.edata_size == 0 {
812 None
813 } else {
814 let eslice = &edata_[(src.tell() as usize)..];
815 Some(eslice.to_vec())
816 };
817 let nainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), extradata);
818 let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, srate));
ce52b3b5
KS		 819 if res.is_none() { return Err(MemoryError); }
820
c19ce782 821 let astr = RMAudioStream::new(ainfo.ileave_info);
ce52b3b5
KS		 822 self.streams.push(RMStreamType::Audio(astr));
823 } else if ((tag2 == mktag!('V', 'I', 'D', 'O')) || (tag2 == mktag!('I', 'M', 'A', 'G'))) && ((tag as usize) <= edata_size) {
824 src.read_skip(4)?;
825 let fcc = src.read_u32be()?;
826 let width = src.read_u16be()? as usize;
827 let height = src.read_u16be()? as usize;
828 let bpp = src.read_u16be()?;
829 let pad_w = src.read_u16be()?;
830 let pad_h = src.read_u16be()?;
831 let fps;
832 if tag2 == mktag!('V', 'I', 'D', 'O') {
833 fps = src.read_u32be()?;
834 } else {
835 fps = 0x10000;
836 }
837 let extradata: Option<Vec<u8>>;
838 if src.left() > 0 {
839 let eslice = &edata_[(src.tell() as usize)..];
840 extradata = Some(eslice.to_vec());
841 } else {
842 extradata = None;
843 }
844 let cname = find_codec_name(RM_VIDEO_CODEC_REGISTER, fcc);
845
846 let vhdr = NAVideoInfo::new(width, height, false, RGB24_FORMAT);
847 let vinfo = NACodecInfo::new(cname, NACodecTypeInfo::Video(vhdr), extradata);
848 let res = strmgr.add_stream(NAStream::new(StreamType::Video, stream_no as u32, vinfo, 0x10000, fps));
849 if res.is_none() { return Err(DemuxerError::MemoryError); }
850
851 let vstr = RMVideoStream::new();
852 self.streams.push(RMStreamType::Video(vstr));
c19ce782
KS		 853 } else if tag == mktag!(b"LSD:") {
854 let extradata = Some(edata_.to_vec());
855
856 src.read_skip(4)?; //version
857 let channels = src.read_u16be()?;
858 let samp_size = src.read_u16be()?;
859 let sample_rate = src.read_u32be()?;
860
861 println!("LSD sr {}, {} ch", sample_rate, channels);
862 let soniton = NASoniton::new(samp_size as u8, SONITON_FLAG_SIGNED);
863 let ahdr = NAAudioInfo::new(sample_rate, channels as u8, soniton, 1);
864 let nainfo = NACodecInfo::new("ralf", NACodecTypeInfo::Audio(ahdr), extradata);
865 let res = strmgr.add_stream(NAStream::new(StreamType::Audio, stream_no as u32, nainfo, 1, sample_rate));
866 if res.is_none() { return Err(MemoryError); }
867 let astr = RMAudioStream::new(None);
868 self.streams.push(RMStreamType::Audio(astr));
ce52b3b5
KS		 869 } else {
870 self.streams.push(RMStreamType::Logical);
871 }
872 }
873 } else {
874 self.streams.push(RMStreamType::Unknown);
875 }
876
877 Ok(())
878 }
879/*#[allow(unused_variables)]
880 fn read_pkt_header(&mut self) -> DemuxerResult<()> {
881 let ver = self.src.read_u16be()?;
882 validate!(ver <= 1);
883 let str_no = self.src.read_u16be()?;
884 let timestamp = self.src.read_u32be()?;
885 if ver == 0 {
886 let pkt_group = self.src.read_byte()?;
887 let pkt_flags = self.src.read_byte()?;
888 } else {
889 let asm_rule = self.src.read_u16be()?;
890 let asm_flags = self.src.read_byte()?;
891 }
892 Ok(())
893 }*/
894}
895
896fn read_string(src: &mut ByteReader) -> DemuxerResult<String> {
897 let mut vec: Vec<u8> = Vec::new();
898 loop {
899 let c = src.read_byte()?;
900 if c == 0 { break; }
901 vec.push(c);
902 }
903 let str = String::from_utf8(vec);
904 if str.is_ok() {
905 Ok(str.unwrap())
906 } else {
907 Ok(String::new())
908 }
909}
910
911fn read_string_size(src: &mut ByteReader, size: usize) -> DemuxerResult<String> {
912 let mut vec: Vec<u8> = Vec::new();
913 for _ in 0..size {
914 let c = src.read_byte()?;
915 vec.push(c);
916 }
917 let str = String::from_utf8(vec);
918 if str.is_ok() {
919 Ok(str.unwrap())
920 } else {
921 Ok(String::new())
922 }
923}
924
925#[allow(dead_code)]
926#[allow(unused_variables)]
927fn parse_rm_stream(io: &mut ByteReader) -> DemuxerResult<NAStream> {
928 let mimetype = read_string(io)?;
929 let strname = read_string(io)?;
930 let strnum = io.read_u32le()?;
931 let maxbr = io.read_u32le()?;
932 let avgbr = io.read_u32le()?;
933 let maxsize = io.read_u32le()?;
934 let avgsize = io.read_u32le()?;
935 let duration = io.read_u32le()?;
936 let preroll = io.read_u32le()?;
937 let start = io.read_u32le()?;
938 let edatalen = io.read_u32le()? as usize;
939 let mut edata: Vec<u8> = Vec::with_capacity(edatalen);
940 edata.resize(edatalen, 0);
941 io.read_buf(&mut edata)?;
942 let numprops = io.read_u32le()? as usize;
943 //read properties
944 unimplemented!();
945}
946
947#[allow(dead_code)]
948#[allow(unused_variables)]
949fn read_ra_vbr_stream(io: &mut ByteReader) -> DemuxerResult<NAPacket> {
950 let hdrsizesize = io.read_u16le()?;
951 let num_entries = (hdrsizesize / 16) as usize;
952 let mut sizes: Vec<usize> = Vec::with_capacity(num_entries);
953 for _ in 0..num_entries {
954 let sz = io.read_u16le()? as usize;
955 sizes.push(sz);
956 }
957 for i in 0..num_entries {
958//read packet of sizes[i]
959 }
960 unimplemented!();
961}
962
963//todo interleavers
964
965//todo opaque data
966
967
968static RM_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
969 (b"RV10", "realvideo1"),
970 (b"RV20", "realvideo2"),
971 (b"RVTR", "realvideo2"),
972 (b"RV30", "realvideo3"),
973 (b"RV40", "realvideo4"),
750b299c 974 (b"CLV1", "clearvideo_rm"),
ce52b3b5
KS		 975];
976
b1ef37ee 977#[allow(dead_code)]
ce52b3b5
KS		 978static RM_AUDIO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
979 (b"lpcJ", "ra14.4"),
980 (b"28_8", "ra28.8"),
981 (b"cook", "cook"),
982 (b"dnet", "ac3"),
983 (b"sipr", "sipro"),
984 (b"atrc", "atrac3"),
985 (b"LSD:", "ralf"),
986 (b"raac", "aac"),
987 (b"racp", "aac"),
988];
989
990pub struct RealMediaDemuxerCreator { }
991
992impl DemuxerCreator for RealMediaDemuxerCreator {
993 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
994 Box::new(RealMediaDemuxer::new(br))
995 }
996 fn get_name(&self) -> &'static str { "realmedia" }
997}
998
999#[cfg(test)]
1000mod test {
1001 use super::*;
1002 use std::fs::File;
1003
1004 #[test]
1005 fn test_rm_demux() {
1006 let mut file =
1007 File::open("assets/RV/rv10_dnet_640x352_realvideo_encoder_4.0.rm").unwrap();
1008// File::open("assets/RV/rv20_cook_640x352_realproducer_plus_8.51.rm").unwrap();
1009// File::open("assets/RV/rv20_svt_atrc_640x352_realproducer_plus_8.51.rm").unwrap();
1010// File::open("assets/RV/rv30_atrc_384x208_realproducer_plus_8.51.rm").unwrap();
1011// File::open("assets/RV/rv30_chroma_drift.rm").unwrap();
1012// File::open("assets/RV/rv30_weighted_mc.rm").unwrap();
1013// File::open("assets/RV/rv40_weighted_mc.rmvb").unwrap();
1014// File::open("assets/RV/rv40_weighted_mc_2.rmvb").unwrap();
1015// File::open("assets/RV/clv1_sipr_384x208_realvideo_encoder_4.0.rm").unwrap();
1016// File::open("assets/RV/luckynight.rmvb").unwrap();
1017// File::open("assets/RV/rv40_ralf.rmvb").unwrap();
1018 let mut fr = FileReader::new_read(&mut file);
1019 let mut br = ByteReader::new(&mut fr);
1020 let mut dmx = RealMediaDemuxer::new(&mut br);
1021 let mut sm = StreamManager::new();
1022 dmx.open(&mut sm).unwrap();
1023
1024 loop {
1025 let pktres = dmx.get_frame(&mut sm);
1026 if let Err(e) = pktres {
1027 if e == DemuxerError::EOF { break; }
1028 panic!("error");
1029 }
1030 let pkt = pktres.unwrap();
1031 println!("Got {}", pkt);
1032 }
41f11b2b 1033//panic!("the end");
ce52b3b5
KS		 1034 }
1035}
NihAV is a research multimedia framework