});
}
+const RM_SIPRO_BLOCK_SIZES: [usize; 4] = [ 29, 19, 37, 20 ];
+const RM_SIPRO_SWAPS: [[u8; 2]; 38] = [
+ [ 0, 63 ], [ 1, 22 ], [ 2, 44 ], [ 3, 90 ],
+ [ 5, 81 ], [ 7, 31 ], [ 8, 86 ], [ 9, 58 ],
+ [ 10, 36 ], [ 12, 68 ], [ 13, 39 ], [ 14, 73 ],
+ [ 15, 53 ], [ 16, 69 ], [ 17, 57 ], [ 19, 88 ],
+ [ 20, 34 ], [ 21, 71 ], [ 24, 46 ], [ 25, 94 ],
+ [ 26, 54 ], [ 28, 75 ], [ 29, 50 ], [ 32, 70 ],
+ [ 33, 92 ], [ 35, 74 ], [ 38, 85 ], [ 40, 56 ],
+ [ 42, 87 ], [ 43, 65 ], [ 45, 59 ], [ 48, 79 ],
+ [ 49, 93 ], [ 51, 89 ], [ 55, 95 ], [ 61, 76 ],
+ [ 67, 83 ], [ 77, 80 ]
+];
+
struct RMVideoStream {
frame: Vec<u8>,
hdr_size: usize,
struct RMAudioStream {
deint: Deinterleaver,
iinfo: Option<InterleaveInfo>,
+ buf: Vec<u8>,
+ sub_packet: usize,
}
const RM_ILEAVE_INT0: u32 = mktag!(b"Int0");
const RM_ILEAVE_INT4: u32 = mktag!(b"Int4");
const RM_ILEAVE_GENR: u32 = mktag!(b"genr");
const RM_ILEAVE_SIPR: u32 = mktag!(b"sipr");
+const RM_ILEAVE_VBRF: u32 = mktag!(b"vbrf");
const RM_ILEAVE_VBRS: u32 = mktag!(b"vbrs");
impl RMAudioStream {
fn new(iinfo: Option<InterleaveInfo>) -> Self {
let deint;
+ let mut buf: Vec<u8>;
if let Some(info) = iinfo {
deint = match info.id {
RM_ILEAVE_INT0 => Deinterleaver::None,
RM_ILEAVE_INT4 => Deinterleaver::RA28_8,
RM_ILEAVE_GENR => Deinterleaver::Generic,
RM_ILEAVE_SIPR => Deinterleaver::Sipro,
+ RM_ILEAVE_VBRF => Deinterleaver::VBR,
RM_ILEAVE_VBRS => Deinterleaver::VBR,
_ => {println!("unknown deint {:X}", info.id); Deinterleaver::None },
};
+ match deint {
+ Deinterleaver::None => { buf = Vec::new(); },
+ Deinterleaver::RA28_8 |
+ Deinterleaver::Generic |
+ Deinterleaver::Sipro => {
+ let bsize = (info.frame_size as usize) * (info.factor as usize);
+ buf = Vec::with_capacity(bsize);
+ buf.resize(bsize, 0u8);
+ },
+ Deinterleaver::VBR => {
+ buf = Vec::new();
+ },
+ };
} else {
deint = Deinterleaver::None;
+ buf = Vec::new();
+ }
+ RMAudioStream { deint: deint, iinfo: iinfo, buf: buf, sub_packet: 0 }
+ }
+ 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> {
+ let (tb_num, tb_den) = stream.get_timebase();
+ let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
+
+ if keyframe {
+ self.sub_packet = 0;
+ }
+ match self.deint {
+ Deinterleaver::None => { return src.read_packet(stream, ts, keyframe, payload_size); },
+ Deinterleaver::RA28_8 => {
+ let iinfo = self.iinfo.unwrap();
+ let factor = iinfo.factor as usize;
+ let halffact = factor >> 1;
+ let fsize = iinfo.frame_size as usize;
+ let bsize = iinfo.block_size as usize;
+ let ppos = self.sub_packet;
+ for sb in 0..halffact {
+ let mut dst = &mut self.buf[sb * 2 * fsize + ppos * bsize..][..bsize];
+ src.read_buf(&mut dst)?;
+ }
+ self.sub_packet += 1;
+ if self.sub_packet == factor {
+ self.sub_packet = 0;
+ return Ok(NAPacket::new(stream, ts, true, self.buf.clone()));
+ } else {
+ return Err(DemuxerError::TryAgain);
+ }
+ },
+ Deinterleaver::Generic => {
+ let iinfo = self.iinfo.unwrap();
+ let factor = iinfo.factor as usize;
+ let fsize = iinfo.frame_size as usize;
+ let bsize = iinfo.block_size as usize;
+ let factor2 = fsize / bsize;
+ let ppos = self.sub_packet;
+
+ for sb in 0..factor2 {
+ let sb_pos = factor * sb + ((factor + 1) >> 1) * (ppos & 1) + (ppos >> 1);
+ let mut dst = &mut self.buf[bsize * sb_pos..][..bsize];
+ src.read_buf(&mut dst)?;
+ }
+ },
+ Deinterleaver::Sipro => {
+ let iinfo = self.iinfo.unwrap();
+ let fsize = iinfo.frame_size as usize;
+ let ppos = self.sub_packet;
+
+ let mut dst = &mut self.buf[fsize * ppos..][..fsize];
+ src.read_buf(&mut dst)?;
+ },
+ Deinterleaver::VBR => {
+ validate!(payload_size >= 5);
+ let hdrsizesize = src.read_u16be()?;
+ let num_entries = (hdrsizesize / 16) as usize;
+ validate!(payload_size >= num_entries * 3 + 2);
+ let mut sizes: Vec<usize> = Vec::with_capacity(num_entries);
+ let mut tot_size = 0;
+ for _ in 0..num_entries {
+ let sz = src.read_u16be()? as usize;
+ tot_size += sz;
+ sizes.push(sz);
+ }
+ validate!(tot_size + num_entries * 2 + 2 == payload_size);
+ let pkt_ts = NATimeInfo::new(None, None, None, tb_num, tb_den);
+ let mut first = true;
+ for size in sizes.iter() {
+ let cur_ts = if first { ts } else { pkt_ts };
+ first = false;
+ let pkt = src.read_packet(stream.clone(), cur_ts, true, *size)?;
+ queued_packets.push(pkt);
+ }
+ queued_packets.reverse();
+ let pkt0 = queued_packets.pop().unwrap();
+ return Ok(pkt0);
+ },
+ };
+
+ let iinfo = self.iinfo.unwrap();
+ let factor = iinfo.factor as usize;
+ let fsize = if iinfo.block_size != 0 { iinfo.block_size } else { iinfo.frame_size } as usize;
+
+ self.sub_packet += 1;
+ if self.sub_packet < factor {
+ return Err(DemuxerError::TryAgain);
+ }
+
+ self.sub_packet = 0;
+
+ if self.deint == Deinterleaver::Sipro {
+ sipro_restore(&mut self.buf, factor, fsize);
+ }
+
+ let mut frames_iter = self.buf.chunks(fsize);
+ let pkt0 = frames_iter.next().unwrap();
+
+ let pkt_ts = NATimeInfo::new(None, None, None, tb_num, tb_den);
+ for pkts in frames_iter {
+ let pkt = NAPacket::new(stream.clone(), pkt_ts, true, pkts.to_vec());
+ queued_packets.push(pkt);
+ }
+ queued_packets.reverse();
+ Ok(NAPacket::new(stream, ts, true, pkt0.to_vec()))
+ }
+}
+
+fn sipro_restore(buf: &mut [u8], factor: usize, fsize: usize) {
+ let stride = factor * fsize * 2 / 96;
+ for i in 0..38 {
+ let mut sidx = (RM_SIPRO_SWAPS[i][0] as usize) * stride;
+ let mut didx = (RM_SIPRO_SWAPS[i][1] as usize) * stride;
+ for _ in 0..stride {
+ let in0 = buf[sidx >> 1];
+ let in1 = buf[didx >> 1];
+ let nib0 = (in0 >> ((sidx & 1) * 4)) & 0xF;
+ let nib1 = (in1 >> ((didx & 1) * 4)) & 0xF;
+
+ buf[didx >> 1] = (nib0 << (4 * (didx & 1))) | (in1 & (0xF << (4 * (!didx & 1))));
+ buf[sidx >> 1] = (nib1 << (4 * (sidx & 1))) | (in0 & (0xF << (4 * (!sidx & 1))));
+
+ sidx += 1;
+ didx += 1;
}
- RMAudioStream { deint: deint, iinfo: iinfo }
}
}
}
let flags = self.src.read_byte()?;
let hdr_size = self.src.tell() - pkt_start;
-//println!("packet @{:X} size {} for {} ts {} grp {} flags {:X}", pkt_start, len, str_no, ts, pkt_grp, flags);
+//println!("packet @{:X} size {} for {} ts {} grp {} flags {:X}", pkt_start, len, str_no, ts, _pkt_grp, flags);
self.cur_packet += 1;
let payload_size = len - (hdr_size as usize);
if packet_num == 1 {
vstr.start_slice(num_pkts, frame_size as usize, self.slice_buf.as_slice());
} else {
- vstr.add_slice(packet_num as usize, self.slice_buf.as_slice());
+ vstr.add_slice(packet_num as usize, self.slice_buf.as_slice());
}
if (packet_num as usize) < num_pkts {
continue;
1 => { // whole frame
let seq_no = self.src.read_byte()?;
//println!(" mode 1 seq {}", seq_no);
- read_video_buf(self.src, stream, ts, keyframe, payload_size - 1)
+ read_video_buf(self.src, stream, ts, keyframe, payload_size - 2)
},
2 => { // last partial frame
let b1 = self.src.read_byte()?;
//println!(" mode 2 pkt {}/{} tail {}/{} seq {}", packet_num, num_pkts, tail_size, frame_size, seq_no);
self.slice_buf.resize(tail_size as usize, 0);
self.src.read_buf(self.slice_buf.as_mut_slice())?;
- vstr.add_slice(packet_num as usize, self.slice_buf.as_slice());
+ if packet_num == 1 && frame_size == tail_size {
+ vstr.start_slice(num_pkts, frame_size as usize, self.slice_buf.as_slice());
+ } else {
+ vstr.add_slice(packet_num as usize, self.slice_buf.as_slice());
+ }
while self.src.tell() < pos + (payload_size as u64) {
let res = read_multiple_frame(self.src, stream.clone(), false, false);
}
},
RMStreamType::Audio(ref mut astr) => {
- let (tb_num, tb_den) = stream.get_timebase();
- let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
- self.src.read_packet(stream, ts, keyframe, payload_size)
+ let ret = astr.read_apackets(&mut self.queued_pkts, &mut self.src, stream, ts, keyframe, payload_size);
+ if let Err(DemuxerError::TryAgain) = ret {
+ continue;
+ }
+ ret
},
_ => {
// self.src.read_skip(payload_size)?;
let id = src.read_u32be()?;
if id == 0 { return Ok((0, 0, 0)); }
let size = src.read_u32be()?;
+if size == 0 {
+ let ver = src.read_u16be()?;
+ validate!(ver <= 1);
+ return Ok((id, 0x0FFFFFFF, ver));
+}
validate!(size >= 10);
let ver = src.read_u16be()?;
validate!(ver <= 1);
fcc: u32,
sample_rate: u32,
sample_size: u16,
+ flavor: u16,
channels: u16,
channel_mask: u32,
granularity: u32,
validate!(end - start <= (header_len as u64) + 2);
Ok(RealAudioInfo {
- fcc: fcc, sample_rate: 8000, sample_size: 16, channels: 1, channel_mask: 0,
+ fcc: fcc, flavor: flavor,
+ sample_rate: 8000, sample_size: 16, channels: 1, channel_mask: 0,
granularity: granularity, bytes_per_minute: bytes_per_minute,
total_bytes: total_bytes, edata_size: 0,
ileave_info: None,
let data_size = src.read_u32be()?;
let _ver4 = src.read_u16be()?; // should be 4
let header_size = src.read_u32be()?;
- let _flavor = src.read_u16be()?;
+ let flavor = src.read_u16be()?;
let granularity = src.read_u32be()?;
let total_bytes = src.read_u32be()?;
let bytes_per_minute = src.read_u32be()?;
let ileave_info = if is_interleaved != 0 {
Some(InterleaveInfo {
- id: interleaver_id, factor: ileave_factor, block_size: ileave_block_size, frame_size: 0,
+ id: interleaver_id, factor: ileave_factor, block_size: granularity as u16,
+ frame_size: ileave_block_size,
})
} else {
None
};
Ok(RealAudioInfo {
- fcc: fcc, sample_rate: sample_rate, sample_size: sample_size as u16, channels: channels, channel_mask: 0,
+ fcc: fcc, flavor: flavor,
+ sample_rate: sample_rate, sample_size: sample_size as u16, channels: channels, channel_mask: 0,
granularity: granularity, bytes_per_minute: bytes_per_minute,
total_bytes: total_bytes & 0xFFFFFF, edata_size: 0,
ileave_info: ileave_info,
let data_size = src.read_u32be()?;
let _ver5 = src.read_u16be()?; // should be 5
let header_size = src.read_u32be()?;
- let _flavor = src.read_u16be()?;
+ let flavor = src.read_u16be()?;
let granularity = src.read_u32be()?;
let total_bytes = src.read_u32be()?;
let bytes_per_minute = src.read_u32be()?;
let _bytes_per_minute2 = src.read_u32be()?;
let ileave_factor = src.read_u16be()?;
- let ileave_block_size = src.read_u16be()?;
let frame_size = src.read_u16be()?;
+ let ileave_block_size = src.read_u16be()?;
let user_data = src.read_u32be()?;
let _sample_rate1 = src.read_u16be()?;
let sample_rate = src.read_u32be()?;
if has_ileave_pattern != 0 {
unimplemented!("ra5 interleave pattern");
}
- let edata_size = src.read_u32be()?;
+ let mut edata_size = src.read_u32be()?;
let end = src.tell();
validate!(end - start <= (header_size as u64) + 10);
- src.read_skip((end as usize) - (header_size as usize))?;
+// src.read_skip(((end - start) as usize) - (header_size as usize) - 10)?;
let ileave_info = if is_interleaved != 0 {
Some(InterleaveInfo {
} else {
None
};
+ if (fcc == mktag!(b"raac")) || (fcc == mktag!(b"racp")) {
+ validate!(edata_size > 1);
+ edata_size -= 1;
+ src.read_skip(1)?;
+ }
Ok(RealAudioInfo {
- fcc: fcc, sample_rate: sample_rate, sample_size: sample_size as u16, channels: channels, channel_mask: 0,
+ fcc: fcc, flavor: flavor,
+ sample_rate: sample_rate, sample_size: sample_size as u16, channels: channels, channel_mask: 0,
granularity: granularity, bytes_per_minute: bytes_per_minute,
total_bytes: total_bytes & 0xFFFFFF, edata_size: edata_size,
ileave_info: ileave_info,
match res {
Ok(last) => { if last { break; } },
Err(DemuxerError::IOError) => { break; },
- Err(etype) => { return Err(etype); },
+ Err(etype) => {
+ if self.data_pos == 0 { // data is not found, report error
+ return Err(etype);
+ }
+ },
};
}
//println!("now @ {:X} / {}", self.src.tell(), self.data_pos);
self.src.seek(SeekFrom::Start(self.data_pos))?;
let num_packets = self.src.read_u32be()?;
let next_data_hdr = self.src.read_u32be()?;
- self.num_packets = num_packets;
+ self.num_packets = if num_packets > 0 { num_packets } else { 0xFFFFFF };
self.cur_packet = 0;
Ok(())
}
};
println!(" got ainfo {:?}", ainfo);
let cname = find_codec_name(RM_AUDIO_CODEC_REGISTER, ainfo.fcc);
+ let blk_size = if ainfo.fcc != mktag!(b"sipr") {
+ ainfo.granularity as usize
+ } else {
+ validate!(ainfo.flavor <= 3);
+ RM_SIPRO_BLOCK_SIZES[ainfo.flavor as usize]
+ };
let srate = ainfo.sample_rate;
let soniton = NASoniton::new(ainfo.sample_size as u8, SONITON_FLAG_SIGNED);
- let ahdr = NAAudioInfo::new(srate, ainfo.channels as u8, soniton, 1);
+ let ahdr = NAAudioInfo::new(srate, ainfo.channels as u8, soniton, blk_size);
let extradata = if ainfo.edata_size == 0 {
None
} else {
unimplemented!();
}
-#[allow(dead_code)]
-#[allow(unused_variables)]
-fn read_ra_vbr_stream(io: &mut ByteReader) -> DemuxerResult<NAPacket> {
- let hdrsizesize = io.read_u16le()?;
- let num_entries = (hdrsizesize / 16) as usize;
- let mut sizes: Vec<usize> = Vec::with_capacity(num_entries);
- for _ in 0..num_entries {
- let sz = io.read_u16le()? as usize;
- sizes.push(sz);
- }
- for i in 0..num_entries {
-//read packet of sizes[i]
- }
- unimplemented!();
-}
-
-//todo interleavers
-
-//todo opaque data
-
-
static RM_VIDEO_CODEC_REGISTER: &'static [(&[u8;4], &str)] = &[
(b"RV10", "realvideo1"),
(b"RV20", "realvideo2"),
projects / nihav.git / blobdiff