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