impl RMAudioStream {
fn new(iinfo: Option<InterleaveInfo>) -> Self {
let deint;
- let mut buf: Vec<u8>;
+ let buf: Vec<u8>;
if let Some(info) = iinfo {
deint = match info.id {
RM_ILEAVE_INT0 => Deinterleaver::None,
Deinterleaver::Generic |
Deinterleaver::Sipro => {
let bsize = (info.frame_size as usize) * (info.factor as usize);
- buf = Vec::with_capacity(bsize);
- buf.resize(bsize, 0u8);
+ buf = vec![0; bsize];
},
Deinterleaver::VBR => {
buf = Vec::new();
deint = Deinterleaver::None;
buf = Vec::new();
}
- RMAudioStream { deint: deint, iinfo: iinfo, buf: buf, sub_packet: 0 }
+ RMAudioStream { deint, iinfo, 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> {
+ 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);
}
}
-fn read_video_buf(src: &mut ByteReader, stream: Rc<NAStream>, ts: u32, keyframe: bool, frame_size: usize) -> DemuxerResult<NAPacket> {
+fn read_video_buf(src: &mut ByteReader, stream: NAStreamRef, ts: u32, keyframe: bool, frame_size: usize) -> DemuxerResult<NAPacket> {
let size = (frame_size as usize) + 9;
- let mut vec: Vec<u8> = Vec::with_capacity(size);
- vec.resize(size, 0);
+ let mut vec: Vec<u8> = vec![0; size];
//v[0] = 0; // 1 slice
vec[4] = 1;
src.read_buf(&mut vec[9..])?;
Ok(NAPacket::new(stream, ts, keyframe, vec))
}
-fn read_multiple_frame(src: &mut ByteReader, stream: Rc<NAStream>, keyframe: bool, skip_mtype: bool) -> DemuxerResult<NAPacket> {
+fn read_multiple_frame(src: &mut ByteReader, stream: NAStreamRef, keyframe: bool, skip_mtype: bool) -> DemuxerResult<NAPacket> {
if !skip_mtype {
let mtype = src.read_byte()?;
validate!(mtype == 0xC0);
} else if ((tag2 == mktag!('V', 'I', 'D', 'O')) || (tag2 == mktag!('I', 'M', 'A', 'G'))) && ((tag as usize) <= edata.len()) {
Self::parse_video_stream(strmgr, &mut str_data.streams, stream_no, &mut src, edata.as_slice(), tag2)?;
} else if tag == mktag!(b"LSD:") {
- let extradata = Some(edata.clone());
+ let extradata = Some(edata.to_owned());
src.read_skip(4)?; //version
let channels = src.read_u16be()?;
Ok(())
}
#[allow(unused_variables)]
- fn parse_packet_payload(src: &mut ByteReader, rmstream: &mut RMStreamType, stream: Rc<NAStream>, slice_buf: &mut Vec<u8>, queued_pkts: &mut Vec<NAPacket>, keyframe: bool, ts: u32, payload_size: usize) -> DemuxerResult<NAPacket> {
+ fn parse_packet_payload(src: &mut ByteReader, rmstream: &mut RMStreamType, stream: NAStreamRef, slice_buf: &mut Vec<u8>, queued_pkts: &mut Vec<NAPacket>, keyframe: bool, ts: u32, payload_size: usize) -> DemuxerResult<NAPacket> {
match rmstream {
RMStreamType::Video(ref mut vstr) => {
validate!(end - start <= (header_len as u64) + 2);
Ok(RealAudioInfo {
- fcc: fcc, flavor: flavor,
+ fcc, 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,
+ granularity, bytes_per_minute,
+ total_bytes, edata_size: 0,
ileave_info: None,
})
}
};
Ok(RealAudioInfo {
- 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,
+ fcc, flavor,
+ sample_rate, sample_size: sample_size as u16, channels, channel_mask: 0,
+ granularity, bytes_per_minute,
total_bytes: total_bytes & 0xFFFFFF, edata_size: 0,
- ileave_info: ileave_info,
+ ileave_info,
})
}
let ileave_info = if is_interleaved != 0 {
Some(InterleaveInfo {
- id: interleaver_id, factor: ileave_factor, block_size: ileave_block_size, frame_size: frame_size,
+ id: interleaver_id, factor: ileave_factor, block_size: ileave_block_size, frame_size,
})
} else {
None
}
Ok(RealAudioInfo {
- 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,
+ fcc, flavor,
+ sample_rate, sample_size: sample_size as u16, channels, channel_mask: 0,
+ granularity, bytes_per_minute,
+ total_bytes: total_bytes & 0xFFFFFF, edata_size,
+ ileave_info,
})
}
//println!("mime = {}", mime);
let edata_size = self.src.read_u32be()? as usize;
let edata: Option<Vec<u8>> = if edata_size == 0 { None } else {
- let mut edvec: Vec<u8> = Vec::with_capacity(edata_size);
- edvec.resize(edata_size, 0);
+ let mut edvec: Vec<u8> = vec![0; edata_size];
self.src.read_buf(&mut edvec)?;
Some(edvec)
};
let extradata = if ainfo.edata_size == 0 {
None
} else {
- let mut dta: Vec<u8> = Vec::with_capacity(ainfo.edata_size as usize);
- dta.resize(ainfo.edata_size as usize, 0);
+ let mut dta: Vec<u8> = vec![0; ainfo.edata_size as usize];
self.src.read_buf(dta.as_mut_slice())?;
Some(dta)
};
impl IVRRecord {
fn read_string(src: &mut ByteReader) -> DemuxerResult<Vec<u8>> {
let len = src.read_u32be()? as usize;
- let mut val = Vec::with_capacity(len);
- val.resize(len, 0);
+ let mut val = vec![0; len];
src.read_buf(val.as_mut_slice())?;
Ok(val)
}
4 => {
let name = Self::read_string(src)?;
let len = src.read_u32be()? as usize;
- let mut val = Vec::with_capacity(len);
- val.resize(len, 0);
+ let mut val = vec![0; len];
src.read_buf(val.as_mut_slice())?;
Ok(IVRRecord::BinaryData(name, val))
},
RecordDemuxer {
start_pos: pos,
cur_pos: pos,
- start_str: start_str,
+ start_str,
remap_ids: Vec::new(),
}
}
loop {
let rec = IVRRecord::read(src)?;
match rec {
- IVRRecord::Packet { ts, str, flags, len, checksum: _ } => {
+ IVRRecord::Packet { ts, str, flags, len, .. } => {
let payload_size = len;
let sr = self.remap_ids.iter().position(|x| *x == str);
validate!(sr.is_some());
pub struct RealMediaDemuxerCreator { }
impl DemuxerCreator for RealMediaDemuxerCreator {
- fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
+ fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
Box::new(RealMediaDemuxer::new(br))
}
fn get_name(&self) -> &'static str { "realmedia" }
pub struct RealAudioDemuxerCreator { }
impl DemuxerCreator for RealAudioDemuxerCreator {
- fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
+ fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
Box::new(RealAudioDemuxer::new(br))
}
fn get_name(&self) -> &'static str { "realaudio" }
pub struct RealIVRDemuxerCreator { }
impl DemuxerCreator for RealIVRDemuxerCreator {
- fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<DemuxCore<'a> + 'a> {
+ fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
Box::new(RealIVRDemuxer::new(br))
}
fn get_name(&self) -> &'static str { "real_ivr" }
projects / nihav.git / blobdiff