use super::*;
+use register;
use super::DemuxerError::*;
use io::byteio::*;
use frame::*;
}
#[allow(dead_code)]
-pub struct AVIDemuxer<'a> {
+struct AVIDemuxer<'a> {
opened: bool,
src: &'a mut ByteReader<'a>,
cur_frame: Vec<u64>,
size: usize,
movi_size: usize,
sstate: StreamState,
+ tb_num: u32,
+ tb_den: u32,
}
-#[derive(Debug,Clone,Copy)]
+#[derive(Debug,Clone,Copy,PartialEq)]
enum RIFFTag {
Chunk(u32),
List(u32,u32),
Ok(())
}
+ fn get_num_streams(&self) -> usize { self.dmx.get_num_streams() }
+ fn get_stream(&self, idx: usize) -> Option<Rc<NAStream>> { self.dmx.get_stream(idx) }
+
fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
if !self.opened { return Err(NoSuchInput); }
if self.movi_size == 0 { return Err(EOF); }
let str = self.dmx.get_stream(stream_no as usize);
if let None = str { return Err(InvalidData); }
let stream = str.unwrap();
- let pkt = self.src.read_packet(stream, Some(self.cur_frame[stream_no as usize]), None, None, false, size)?;
+ let (tb_num, tb_den) = stream.get_timebase();
+ let ts = NATimeInfo::new(Some(self.cur_frame[stream_no as usize]), None, None, tb_num, tb_den);
+ let pkt = self.src.read_packet(stream, ts, false, size)?;
self.cur_frame[stream_no as usize] += 1;
self.movi_size -= size + 8;
}
impl<'a> AVIDemuxer<'a> {
- pub fn new(io: &'a mut ByteReader<'a>) -> Self {
+ fn new(io: &'a mut ByteReader<'a>) -> Self {
AVIDemuxer {
cur_frame: Vec::new(),
num_streams: 0,
size: 0,
movi_size: 0,
sstate: StreamState::new(),
+ tb_num: 0,
+ tb_den: 0,
dmx: Demuxer::new()
}
}
let tag = self.src.read_u32be()?;
let size = self.src.read_u32le()? as usize;
if size > csize { return Err(InvalidData); }
- if let RIFFTag::Chunk(etag) = end_tag {
- if etag == tag { return Ok((size, true)); }
+ if RIFFTag::Chunk(tag) == end_tag {
+ return Ok((size, true));
}
let ltag = if is_list_tag(tag) { self.src.read_u32be()? } else { 0 };
- if let RIFFTag::List(etag1, etag2) = end_tag {
- if etag1 == tag && etag2 == ltag {
- return Ok((size, true));
- }
+ if RIFFTag::List(tag, ltag) == end_tag {
+ return Ok((size, true));
}
-
+
for i in 0..CHUNKS.len() {
- if let RIFFTag::Chunk(ctag) = CHUNKS[i].tag {
- if ctag == tag {
- let psize = (CHUNKS[i].parse)(self, size)?;
- if psize != size { return Err(InvalidData); }
- return Ok((size + 8, false));
- }
+ if RIFFTag::Chunk(tag) == CHUNKS[i].tag {
+ let psize = (CHUNKS[i].parse)(self, size)?;
+ if psize != size { return Err(InvalidData); }
+ return Ok((size + 8, false));
}
- if let RIFFTag::List(ctag, clst) = CHUNKS[i].tag {
- if ctag == tag && clst == ltag {
- let mut rest_size = size - 4;
- let psize = (CHUNKS[i].parse)(self, rest_size)?;
+ if RIFFTag::List(tag, ltag) == CHUNKS[i].tag {
+ let mut rest_size = size - 4;
+ let psize = (CHUNKS[i].parse)(self, rest_size)?;
+ if psize > rest_size { return Err(InvalidData); }
+ rest_size -= psize;
+ while rest_size > 0 {
+ let (psize, _) = self.parse_chunk(end_tag, rest_size, depth+1)?;
if psize > rest_size { return Err(InvalidData); }
rest_size -= psize;
- while rest_size > 0 {
- let (psize, _) = self.parse_chunk(end_tag, rest_size, depth+1)?;
- if psize > rest_size { return Err(InvalidData); }
- rest_size -= psize;
- }
-
- return Ok((size + 8, false));
}
+
+ return Ok((size + 8, false));
}
}
self.src.read_skip(size)?;
dmx.src.read_skip(2)?; //priority
dmx.src.read_skip(2)?; //language
dmx.src.read_skip(4)?; //initial frames
- let scale = dmx.src.read_u32le()?; //scale
- let rate = dmx.src.read_u32le()?; //rate
+ dmx.tb_num = dmx.src.read_u32le()?; //scale
+ dmx.tb_den = dmx.src.read_u32le()?; //rate
dmx.src.read_skip(4)?; //start
dmx.src.read_skip(4)?; //length
dmx.src.read_skip(4)?; //buf size
let height = dmx.src.read_u32le()? as i32;
let planes = dmx.src.read_u16le()?;
let bitcount = dmx.src.read_u16le()?;
- let compression = dmx.src.read_u32be()?;
+ let mut compression: [u8; 4] = [0; 4];
+ dmx.src.read_buf(&mut compression)?;
let img_size = dmx.src.read_u32le()?;
let xdpi = dmx.src.read_u32le()?;
let ydpi = dmx.src.read_u32le()?;
let flip = height < 0;
let format = if bitcount > 8 { RGB24_FORMAT } else { PAL8_FORMAT };
- let vhdr = NAVideoInfo::new(width, if flip { -height as u32 } else { height as u32}, flip, PAL8_FORMAT);
+ let vhdr = NAVideoInfo::new(width as usize, if flip { -height as usize } else { height as usize}, flip, PAL8_FORMAT);
let vci = NACodecTypeInfo::Video(vhdr);
let edata = dmx.read_extradata(size - 40)?;
- let vinfo = NACodecInfo::new(vci, edata);
- let res = dmx.dmx.add_stream(NAStream::new(StreamType::Video, dmx.sstate.strm_no as u32, vinfo));
+ let cname = match register::find_codec_from_avi_fourcc(&compression) {
+ None => "unknown",
+ Some(name) => name,
+ };
+ let vinfo = NACodecInfo::new(cname, vci, edata);
+ let res = dmx.dmx.add_stream(NAStream::new(StreamType::Video, dmx.sstate.strm_no as u32, vinfo, dmx.tb_num, dmx.tb_den));
if let None = res { return Err(MemoryError); }
dmx.sstate.reset();
Ok(size)
let soniton = NASoniton::new(bits_per_sample as u8, SONITON_FLAG_SIGNED);
let ahdr = NAAudioInfo::new(samplespersec, channels as u8, soniton, block_align as usize);
let edata = dmx.read_extradata(size - 16)?;
- let ainfo = NACodecInfo::new(NACodecTypeInfo::Audio(ahdr), edata);
- let res = dmx.dmx.add_stream(NAStream::new(StreamType::Audio, dmx.sstate.strm_no as u32, ainfo));
+ let cname = match register::find_codec_from_wav_twocc(w_format_tag) {
+ None => "unknown",
+ Some(name) => name,
+ };
+ let ainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata);
+ let res = dmx.dmx.add_stream(NAStream::new(StreamType::Audio, dmx.sstate.strm_no as u32, ainfo, dmx.tb_num, dmx.tb_den));
if let None = res { return Err(MemoryError); }
dmx.sstate.reset();
Ok(size)
fn parse_strf_xxxx(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
let edata = dmx.read_extradata(size)?;
- let info = NACodecInfo::new(NACodecTypeInfo::None, edata);
- let res = dmx.dmx.add_stream(NAStream::new(StreamType::Data, dmx.sstate.strm_no as u32, info));
+ let info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata);
+ let res = dmx.dmx.add_stream(NAStream::new(StreamType::Data, dmx.sstate.strm_no as u32, info, dmx.tb_num, dmx.tb_den));
if let None = res { return Err(MemoryError); }
dmx.sstate.reset();
Ok(size)
Ok(size)
}
+pub struct AVIDemuxerCreator { }
+
+impl DemuxerCreator for AVIDemuxerCreator {
+ fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<Demux<'a> + 'a> {
+ Box::new(AVIDemuxer::new(br))
+ }
+ fn get_name(&self) -> &'static str { "avi" }
+}
+
#[cfg(test)]
mod test {
use super::*;
loop {
let pktres = dmx.get_frame();
if let Err(e) = pktres {
- if (e as i32) == (DemuxerError::EOF as i32) { break; }
+ if e == DemuxerError::EOF { break; }
panic!("error");
}
let pkt = pktres.unwrap();
projects / nihav.git / blobdiff