struct RMAudioStream {
deint: Deinterleaver,
iinfo: Option<InterleaveInfo>,
+ buf: Vec<u8>,
+ sub_packet: usize,
}
const RM_ILEAVE_INT0: u32 = mktag!(b"Int0");
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_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 => { unimplemented!("deint"); },
+ };
} else {
deint = Deinterleaver::None;
+ buf = Vec::new();
}
- RMAudioStream { deint: deint, iinfo: iinfo }
+ 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)?;
+ },
+ _ => { return src.read_packet(stream, ts, keyframe, payload_size); },
+ };
+
+ let iinfo = self.iinfo.unwrap();
+ let factor = iinfo.factor as usize;
+ let fsize = 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 {
+// todo sipro deinterleave
+ }
+
+ 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()))
}
}
}
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);
//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);
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
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()?;
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(())
}
projects / nihav.git / blobdiff