RMAudioStream { deint, iinfo, buf, sub_packet: 0 }
}
fn read_apackets(&mut self, queued_packets: &mut Vec<NAPacket>, src: &mut ByteReader, stream: NAStreamRef, 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);
+ let ts = stream.make_ts(Some(ts as u64), None, None);
if keyframe {
self.sub_packet = 0;
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 pkt_ts = stream.make_ts(None, None, None);
let mut first = true;
for size in sizes.iter() {
let cur_ts = if first { ts } else { pkt_ts };
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);
+ let pkt_ts = stream.make_ts(None, None, None);
for pkts in frames_iter {
let pkt = NAPacket::new(stream.clone(), pkt_ts, true, pkts.to_vec());
queued_packets.push(pkt);
vec[4] = 1;
src.read_buf(&mut vec[9..])?;
- let (tb_num, tb_den) = stream.get_timebase();
- let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
+ let ts = stream.make_ts(Some(ts as u64), None, None);
Ok(NAPacket::new(stream, ts, keyframe, vec))
}
return Err(DemuxerError::TryAgain);
}
//todo: check if full frame is received
- let (tb_num, tb_den) = stream.get_timebase();
- let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
+ let ts = stream.make_ts(Some(ts as u64), None, None);
let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
Ok(pkt)
},
queued_pkts.push(res.unwrap());
}
queued_pkts.reverse();
- let (tb_num, tb_den) = stream.get_timebase();
- let ts = NATimeInfo::new(Some(ts as u64), None, None, tb_num, tb_den);
+ let ts = stream.make_ts(Some(ts as u64), None, None);
let pkt = NAPacket::new(stream, ts, keyframe, vstr.get_frame_data());
Ok(pkt)
},
let c = src.read_byte()?;
vec.push(c);
}
- let str = String::from_utf8(vec);
- if let Ok(res) = str {
+ if let Ok(res) = String::from_utf8(vec) {
Ok(res)
} else {
Ok(String::new())
enum IVRRecord {
Invalid(u8),
StreamProperties(usize),
- Packet { ts: u32, str: u32, flags: u32, len: usize, checksum: u32 },
+ Packet { ts: u32, strm: u32, flags: u32, len: usize, checksum: u32 },
IntValue(Vec<u8>, u32),
BinaryData(Vec<u8>, Vec<u8>),
StringData(Vec<u8>, Vec<u8>),
},
2 => {
let ts = src.read_u32be()?;
- let str = src.read_u16be()? as u32;
+ let strm = src.read_u16be()? as u32;
let flags = src.read_u32be()?;
let len = src.read_u32be()? as usize;
let chk = src.read_u32be()?;
validate!((len > 0) && (len < (1 << 24)));
- Ok(IVRRecord::Packet { ts, str, flags, len, checksum: chk })
+ Ok(IVRRecord::Packet { ts, strm, flags, len, checksum: chk })
},
3 => {
let name = Self::read_string(src)?;
IVRRecord::Invalid(typ) => write!(f, "Invalid({:02X})", typ),
IVRRecord::StreamProperties(num) =>
write!(f, "({} stream properties)", num),
- IVRRecord::Packet { ts, str, flags, len, checksum } =>
- write!(f, "paket({}, {}, {:X}, {}, {})", ts, str, flags, len, checksum),
+ IVRRecord::Packet { ts, strm, flags, len, checksum } =>
+ write!(f, "paket({}, {}, {:X}, {}, {})", ts, strm, flags, len, checksum),
IVRRecord::IntValue(ref name, val) =>
write!(f, "({} = {})", String::from_utf8_lossy(name), val),
IVRRecord::BinaryData(ref name, ref val) =>
loop {
let rec = IVRRecord::read(src)?;
match rec {
- IVRRecord::Packet { ts, str, flags, len, .. } => {
+ IVRRecord::Packet { ts, strm, flags, len, .. } => {
let payload_size = len;
- let sr = self.remap_ids.iter().position(|x| *x == str);
+ let sr = self.remap_ids.iter().position(|x| *x == strm);
validate!(sr.is_some());
let str_no = self.start_str + (sr.unwrap() as u32);
let pkt_grp = ((flags >> 8) & 0xFF) as u16;