[nihav.git] / src / demuxers / avi.rs

use super::*;
use super::DemuxerError::*;
use io::byteio::*;
use frame::*;
use formats::*;

macro_rules! mktag {
    ($a:expr, $b:expr, $c:expr, $d:expr) => ({
        (($a as u32) << 24) | (($b as u32) << 16) | (($c as u32) << 8) | ($d as u32)
    });
    ($arr:expr) => ({
        (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
    });
}

struct StreamState {
    strm_no:    u8,
    got_strf:   bool,
    strm_type:  Option<StreamType>,
}

impl StreamState {
    fn new() -> Self {
        StreamState { strm_no: 0, got_strf: true, strm_type: None }
    }
    fn reset(&mut self) {
        self.strm_type = None;
        self.got_strf  = true;
        self.strm_no  += 1;
    }
    fn valid_state(&self) -> bool {
        match self.strm_type {
            None => self.got_strf,
            _    => false,
        }
    }
}

#[allow(dead_code)]
pub struct AVIDemuxer<'a> {
    opened:         bool,
    src:            &'a mut ByteReader<'a>,
    cur_frame:      Vec<u64>,
    num_streams:    u8,
    dmx:            Demuxer,
    size:           usize,
    movi_size:      usize,
    sstate:         StreamState,
}

#[derive(Debug,Clone,Copy,PartialEq)]
enum RIFFTag {
    Chunk(u32),
    List(u32,u32),
}

struct RIFFParser {
    tag:   RIFFTag,
    parse: fn(&mut AVIDemuxer, size: usize) -> DemuxerResult<usize>,
}

impl<'a> Demux<'a> for AVIDemuxer<'a> {
    #[allow(unused_variables)]
    fn open(&mut self) -> DemuxerResult<()> {
        self.read_header()?;
        self.opened = true;
        Ok(())
    }

    fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
        if !self.opened { return Err(NoSuchInput); }
        if self.movi_size == 0 { return Err(EOF); }
        let mut tag: [u8; 4] = [0; 4];
        loop {
            self.src.read_buf(&mut tag)?;
            let size = self.src.read_u32le()? as usize;
            if mktag!(tag) == mktag!(b"JUNK") {
                self.movi_size -= size + 8;
                self.src.read_skip(size)?;
                continue;
            }
            if tag[0] < b'0' || tag[0] > b'9' || tag[1] < b'0' || tag[1] > b'9' {
                return Err(InvalidData);
            }
            let stream_no = (tag[0] - b'0') * 10 + (tag[1] - b'0');
            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)?;
            self.cur_frame[stream_no as usize] += 1;            
            self.movi_size -= size + 8;

            return Ok(pkt);
        }
    }

    #[allow(unused_variables)]
    fn seek(&mut self, time: u64) -> DemuxerResult<()> {
        if !self.opened { return Err(NoSuchInput); }
        Err(NotImplemented)
    }
}

impl<'a> AVIDemuxer<'a> {
    pub fn new(io: &'a mut ByteReader<'a>) -> Self {
        AVIDemuxer {
            cur_frame: Vec::new(),
            num_streams: 0,
            opened: false,
            src: io,
            size: 0,
            movi_size: 0,
            sstate: StreamState::new(),
            dmx: Demuxer::new()
        }
    }

    fn parse_chunk(&mut self, end_tag: RIFFTag, csize: usize, depth: u16) -> DemuxerResult<(usize, bool)> {
        if csize < 8 { return Err(InvalidData); }
        if depth > 42 { return Err(InvalidData); }

        let tag  = self.src.read_u32be()?;
        let size = self.src.read_u32le()? as usize;
        if size > csize { return Err(InvalidData); }
        if RIFFTag::Chunk(tag) == end_tag {
            return Ok((size, true));
        }
        let ltag = if is_list_tag(tag) { self.src.read_u32be()? } else { 0 };
        if RIFFTag::List(tag, ltag) == end_tag {
            return Ok((size, true));
        }

        for i in 0..CHUNKS.len() {
            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 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;
                }

                return Ok((size + 8, false));
            }
        }
        self.src.read_skip(size)?;
        return Ok((size + 8, false));
    }

    fn read_header(&mut self) -> DemuxerResult<()> {
        let riff_tag = self.src.read_u32be()?;
        let size     = self.src.read_u32le()? as usize;
        let avi_tag  = self.src.read_u32be()?;
        if riff_tag != mktag!(b"RIFF") || avi_tag != mktag!(b"AVI ") {
            return Err(InvalidData);
        }
        self.size = size;
        let mut rest_size = size;
        loop {
            let (csz, end) = self.parse_chunk(RIFFTag::List(mktag!(b"LIST"), mktag!(b"movi")), rest_size,0)?;
            if end { self.movi_size = csz - 4; break; }
            rest_size -= csz;
        }
        if !self.sstate.valid_state() || self.sstate.strm_no != self.num_streams {
            return Err(InvalidData);
        }
        Ok(())
    }

    fn read_extradata(&mut self, size: usize) -> DemuxerResult<Option<Vec<u8>>> {
        if size == 0 { return Ok(None); }
        let mut edvec: Vec<u8> = Vec::with_capacity(size);
        edvec.resize(size, 0);
        self.src.read_buf(&mut edvec)?;
        Ok(Some(edvec))
    }
}

const CHUNKS: [RIFFParser; 6] = [
    RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"hdrl")), parse: parse_hdrl },
    RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"strl")), parse: parse_strl },
    RIFFParser { tag: RIFFTag::Chunk(mktag!(b"avih")), parse: parse_avih },
    RIFFParser { tag: RIFFTag::Chunk(mktag!(b"strf")), parse: parse_strf },
    RIFFParser { tag: RIFFTag::Chunk(mktag!(b"strh")), parse: parse_strh },
    RIFFParser { tag: RIFFTag::Chunk(mktag!(b"JUNK")), parse: parse_junk },
];

fn is_list_tag(tag: u32) -> bool {
    for i in 0..CHUNKS.len() {
        if let RIFFTag::List(ltag, _) = CHUNKS[i].tag {
            if tag == ltag {
                return true;
            }
        }
    }
    false
}

#[allow(unused_variables)]
fn parse_hdrl(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
    Ok(0)
}

#[allow(unused_variables)]
fn parse_strl(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
    Ok(0)
}

#[allow(unused_variables)]
fn parse_strh(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
    if size < 0x38 { return Err(InvalidData); }
    let tag = dmx.src.read_u32be()?; //stream type
    let fcc = dmx.src.read_u32be()?; //handler(fourcc)
    dmx.src.read_u32le()?; //flags
    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.src.read_skip(4)?; //start
    dmx.src.read_skip(4)?; //length
    dmx.src.read_skip(4)?; //buf size
    dmx.src.read_skip(4)?; //quality
    dmx.src.read_skip(4)?; //sample size
    let a = dmx.src.read_u16le()?;
    let b = dmx.src.read_u16le()?;
    let c = dmx.src.read_u16le()?;
    let d = dmx.src.read_u16le()?;

    dmx.src.read_skip(size - 0x38)?;

    if !dmx.sstate.valid_state() || dmx.sstate.strm_no >= dmx.num_streams {
        return Err(InvalidData);
    }
    if tag == mktag!(b"vids") {
        dmx.sstate.strm_type = Some(StreamType::Video);
    } else if tag == mktag!(b"auds") {
        dmx.sstate.strm_type = Some(StreamType::Audio);
    } else {
        dmx.sstate.strm_type = Some(StreamType::Data);
    }
    dmx.sstate.got_strf = false;

    Ok(size)
}

fn parse_strf(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
    if let None = dmx.sstate.strm_type { return Err(InvalidData); }
    match dmx.sstate.strm_type.unwrap() {
        StreamType::Video    => parse_strf_vids(dmx, size),
        StreamType::Audio    => parse_strf_auds(dmx, size),
        _                    => parse_strf_xxxx(dmx, size),
    }
}

#[allow(unused_variables)]
fn parse_strf_vids(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
    if size < 40 { return Err(InvalidData); }
    let bi_size         = dmx.src.read_u32le()?;
    if (bi_size as usize) > size { return Err(InvalidData); }
    let width           = dmx.src.read_u32le()?;
    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 img_size        = dmx.src.read_u32le()?;
    let xdpi            = dmx.src.read_u32le()?;
    let ydpi            = dmx.src.read_u32le()?;
    let colors          = dmx.src.read_u32le()?;
    let imp_colors      = 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 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));
    if let None = res { return Err(MemoryError); }
    dmx.sstate.reset();
    Ok(size)
}

#[allow(unused_variables)]
fn parse_strf_auds(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
    if size < 16 { return Err(InvalidData); }
    let w_format_tag        = dmx.src.read_u16le()?;
    let channels            = dmx.src.read_u16le()?;
    let samplespersec       = dmx.src.read_u32le()?;
    let avgbytespersec      = dmx.src.read_u32le()?;
    let block_align         = dmx.src.read_u16le()?;
    let bits_per_sample     = dmx.src.read_u16le()?;

    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));
    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));
    if let None = res { return Err(MemoryError); }
    dmx.sstate.reset();
    Ok(size)
}

#[allow(unused_variables)]
fn parse_avih(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
    if size < 0x38 { return Err(InvalidData); }
    let timebase = dmx.src.read_u32le()?; //microsec per frame
    dmx.src.read_skip(4)?; //max frame size
    dmx.src.read_skip(4)?; //padding
    dmx.src.read_u32le()?; //flags
    let frames = dmx.src.read_u32le()?; //frames
    dmx.src.read_skip(4)?; //initial frames
    let streams = dmx.src.read_u32le()?; //streams
    if streams > 100 { return Err(InvalidData); }
    dmx.num_streams = streams as u8;

    dmx.src.read_skip(4)?; //buf size
    let width = dmx.src.read_u32le()?; //width
    let height = dmx.src.read_u32le()? as i32; //height
    dmx.src.read_skip(16)?; //reserved

    dmx.cur_frame.resize(streams as usize, 0);
    dmx.src.read_skip(size - 0x38)?;
    Ok(size)
}

fn parse_junk(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
    dmx.src.read_skip(size)?;
    Ok(size)
}

#[cfg(test)]
mod test {
    use super::*;
    use std::fs::File;

    #[test]
    fn test_avi_demux() {
        let mut file = File::open("assets/laser05.avi").unwrap();
        let mut fr = FileReader::new_read(&mut file);
        let mut br = ByteReader::new(&mut fr);
        let mut dmx = AVIDemuxer::new(&mut br);
        dmx.open().unwrap();

        loop {
            let pktres = dmx.get_frame();
            if let Err(e) = pktres {
                if (e as i32) == (DemuxerError::EOF as i32) { break; }
                panic!("error");
            }
            let pkt = pktres.unwrap();
            println!("Got {}", pkt);
        }
    }
}
Commit	Line	Data
ca41f125 KS	1	use super::*;
	2	use super::DemuxerError::*;
	3	use io::byteio::*;
	4	use frame::*;
	5	use formats::*;
	6
	7	macro_rules! mktag {
	8	($a:expr, $b:expr, $c:expr, $d:expr) => ({
	9	(($a as u32) << 24) \| (($b as u32) << 16) \| (($c as u32) << 8) \| ($d as u32)
	10	});
	11	($arr:expr) => ({
	12	(($arr[0] as u32) << 24) \| (($arr[1] as u32) << 16) \| (($arr[2] as u32) << 8) \| ($arr[3] as u32)
	13	});
	14	}
	15
	16	struct StreamState {
	17	strm_no: u8,
	18	got_strf: bool,
	19	strm_type: Option<StreamType>,
	20	}
	21
	22	impl StreamState {
	23	fn new() -> Self {
	24	StreamState { strm_no: 0, got_strf: true, strm_type: None }
	25	}
	26	fn reset(&mut self) {
	27	self.strm_type = None;
	28	self.got_strf = true;
	29	self.strm_no += 1;
	30	}
	31	fn valid_state(&self) -> bool {
	32	match self.strm_type {
	33	None => self.got_strf,
	34	_ => false,
	35	}
	36	}
	37	}
	38
	39	#[allow(dead_code)]
	40	pub struct AVIDemuxer<'a> {
	41	opened: bool,
	42	src: &'a mut ByteReader<'a>,
	43	cur_frame: Vec<u64>,
	44	num_streams: u8,
	45	dmx: Demuxer,
	46	size: usize,
	47	movi_size: usize,
	48	sstate: StreamState,
	49	}
	50
c84e0be0	51	#[derive(Debug,Clone,Copy,PartialEq)]
ca41f125 KS	52	enum RIFFTag {
	53	Chunk(u32),
	54	List(u32,u32),
	55	}
	56
	57	struct RIFFParser {
	58	tag: RIFFTag,
	59	parse: fn(&mut AVIDemuxer, size: usize) -> DemuxerResult<usize>,
	60	}
	61
	62	impl<'a> Demux<'a> for AVIDemuxer<'a> {
	63	#[allow(unused_variables)]
	64	fn open(&mut self) -> DemuxerResult<()> {
	65	self.read_header()?;
	66	self.opened = true;
	67	Ok(())
	68	}
	69
	70	fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
	71	if !self.opened { return Err(NoSuchInput); }
	72	if self.movi_size == 0 { return Err(EOF); }
	73	let mut tag: [u8; 4] = [0; 4];
	74	loop {
	75	self.src.read_buf(&mut tag)?;
	76	let size = self.src.read_u32le()? as usize;
	77	if mktag!(tag) == mktag!(b"JUNK") {
	78	self.movi_size -= size + 8;
	79	self.src.read_skip(size)?;
	80	continue;
	81	}
	82	if tag[0] < b'0' \|\| tag[0] > b'9' \|\| tag[1] < b'0' \|\| tag[1] > b'9' {
	83	return Err(InvalidData);
	84	}
	85	let stream_no = (tag[0] - b'0') * 10 + (tag[1] - b'0');
	86	let str = self.dmx.get_stream(stream_no as usize);
	87	if let None = str { return Err(InvalidData); }
	88	let stream = str.unwrap();
	89	let pkt = self.src.read_packet(stream, Some(self.cur_frame[stream_no as usize]), None, None, false, size)?;
	90	self.cur_frame[stream_no as usize] += 1;
	91	self.movi_size -= size + 8;
	92
	93	return Ok(pkt);
	94	}
	95	}
	96
	97	#[allow(unused_variables)]
	98	fn seek(&mut self, time: u64) -> DemuxerResult<()> {
	99	if !self.opened { return Err(NoSuchInput); }
	100	Err(NotImplemented)
	101	}
	102	}
	103
	104	impl<'a> AVIDemuxer<'a> {
	105	pub fn new(io: &'a mut ByteReader<'a>) -> Self {
	106	AVIDemuxer {
	107	cur_frame: Vec::new(),
	108	num_streams: 0,
	109	opened: false,
	110	src: io,
	111	size: 0,
	112	movi_size: 0,
	113	sstate: StreamState::new(),
	114	dmx: Demuxer::new()
	115	}
116	}
117
118	fn parse_chunk(&mut self, end_tag: RIFFTag, csize: usize, depth: u16) -> DemuxerResult<(usize, bool)> {
119	if csize < 8 { return Err(InvalidData); }
120	if depth > 42 { return Err(InvalidData); }
121
122	let tag = self.src.read_u32be()?;
123	let size = self.src.read_u32le()? as usize;
124	if size > csize { return Err(InvalidData); }
c84e0be0 KS	125	if RIFFTag::Chunk(tag) == end_tag {
c84e0be0 KS	126	return Ok((size, true));
ca41f125 KS	127	}
ca41f125 KS	128	let ltag = if is_list_tag(tag) { self.src.read_u32be()? } else { 0 };
c84e0be0 KS	129	if RIFFTag::List(tag, ltag) == end_tag {
c84e0be0 KS	130	return Ok((size, true));
ca41f125	131	}
c84e0be0	132
ca41f125	133	for i in 0..CHUNKS.len() {
c84e0be0 KS	134	if RIFFTag::Chunk(tag) == CHUNKS[i].tag {
	135	let psize = (CHUNKS[i].parse)(self, size)?;
	136	if psize != size { return Err(InvalidData); }
	137	return Ok((size + 8, false));
ca41f125	138	}
c84e0be0 KS	139	if RIFFTag::List(tag, ltag) == CHUNKS[i].tag {
	140	let mut rest_size = size - 4;
	141	let psize = (CHUNKS[i].parse)(self, rest_size)?;
	142	if psize > rest_size { return Err(InvalidData); }
	143	rest_size -= psize;
	144	while rest_size > 0 {
	145	let (psize, _) = self.parse_chunk(end_tag, rest_size, depth+1)?;
ca41f125 KS	146	if psize > rest_size { return Err(InvalidData); }
ca41f125 KS	147	rest_size -= psize;
ca41f125	148	}
c84e0be0 KS	149
c84e0be0 KS	150	return Ok((size + 8, false));
ca41f125 KS	151	}
	152	}
	153	self.src.read_skip(size)?;
	154	return Ok((size + 8, false));
	155	}
	156
	157	fn read_header(&mut self) -> DemuxerResult<()> {
	158	let riff_tag = self.src.read_u32be()?;
	159	let size = self.src.read_u32le()? as usize;
	160	let avi_tag = self.src.read_u32be()?;
	161	if riff_tag != mktag!(b"RIFF") \|\| avi_tag != mktag!(b"AVI ") {
	162	return Err(InvalidData);
	163	}
	164	self.size = size;
	165	let mut rest_size = size;
	166	loop {
	167	let (csz, end) = self.parse_chunk(RIFFTag::List(mktag!(b"LIST"), mktag!(b"movi")), rest_size,0)?;
	168	if end { self.movi_size = csz - 4; break; }
	169	rest_size -= csz;
	170	}
	171	if !self.sstate.valid_state() \|\| self.sstate.strm_no != self.num_streams {
	172	return Err(InvalidData);
	173	}
	174	Ok(())
	175	}
	176
	177	fn read_extradata(&mut self, size: usize) -> DemuxerResult<Option<Vec<u8>>> {
	178	if size == 0 { return Ok(None); }
	179	let mut edvec: Vec<u8> = Vec::with_capacity(size);
	180	edvec.resize(size, 0);
	181	self.src.read_buf(&mut edvec)?;
	182	Ok(Some(edvec))
	183	}
	184	}
	185
	186	const CHUNKS: [RIFFParser; 6] = [
	187	RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"hdrl")), parse: parse_hdrl },
	188	RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"strl")), parse: parse_strl },
	189	RIFFParser { tag: RIFFTag::Chunk(mktag!(b"avih")), parse: parse_avih },
	190	RIFFParser { tag: RIFFTag::Chunk(mktag!(b"strf")), parse: parse_strf },
	191	RIFFParser { tag: RIFFTag::Chunk(mktag!(b"strh")), parse: parse_strh },
	192	RIFFParser { tag: RIFFTag::Chunk(mktag!(b"JUNK")), parse: parse_junk },
	193	];
	194
	195	fn is_list_tag(tag: u32) -> bool {
	196	for i in 0..CHUNKS.len() {
	197	if let RIFFTag::List(ltag, _) = CHUNKS[i].tag {
	198	if tag == ltag {
	199	return true;
	200	}
	201	}
	202	}
	203	false
	204	}
	205
	206	#[allow(unused_variables)]
	207	fn parse_hdrl(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
	208	Ok(0)
	209	}
	210
	211	#[allow(unused_variables)]
	212	fn parse_strl(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
	213	Ok(0)
	214	}
215
216	#[allow(unused_variables)]
217	fn parse_strh(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
218	if size < 0x38 { return Err(InvalidData); }
219	let tag = dmx.src.read_u32be()?; //stream type
220	let fcc = dmx.src.read_u32be()?; //handler(fourcc)
221	dmx.src.read_u32le()?; //flags
222	dmx.src.read_skip(2)?; //priority
223	dmx.src.read_skip(2)?; //language
224	dmx.src.read_skip(4)?; //initial frames
225	let scale = dmx.src.read_u32le()?; //scale
226	let rate = dmx.src.read_u32le()?; //rate
227	dmx.src.read_skip(4)?; //start
228	dmx.src.read_skip(4)?; //length
229	dmx.src.read_skip(4)?; //buf size
230	dmx.src.read_skip(4)?; //quality
231	dmx.src.read_skip(4)?; //sample size
232	let a = dmx.src.read_u16le()?;
233	let b = dmx.src.read_u16le()?;
234	let c = dmx.src.read_u16le()?;
235	let d = dmx.src.read_u16le()?;
236
237	dmx.src.read_skip(size - 0x38)?;
238
239	if !dmx.sstate.valid_state() \|\| dmx.sstate.strm_no >= dmx.num_streams {
240	return Err(InvalidData);
241	}
242	if tag == mktag!(b"vids") {
243	dmx.sstate.strm_type = Some(StreamType::Video);
244	} else if tag == mktag!(b"auds") {
245	dmx.sstate.strm_type = Some(StreamType::Audio);
246	} else {
247	dmx.sstate.strm_type = Some(StreamType::Data);
248	}
249	dmx.sstate.got_strf = false;
250
251	Ok(size)
252	}
253
254	fn parse_strf(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
255	if let None = dmx.sstate.strm_type { return Err(InvalidData); }
256	match dmx.sstate.strm_type.unwrap() {
257	StreamType::Video => parse_strf_vids(dmx, size),
258	StreamType::Audio => parse_strf_auds(dmx, size),
259	_ => parse_strf_xxxx(dmx, size),
260	}
261	}
262
263	#[allow(unused_variables)]
264	fn parse_strf_vids(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
265	if size < 40 { return Err(InvalidData); }
266	let bi_size = dmx.src.read_u32le()?;
267	if (bi_size as usize) > size { return Err(InvalidData); }
268	let width = dmx.src.read_u32le()?;
269	let height = dmx.src.read_u32le()? as i32;
270	let planes = dmx.src.read_u16le()?;
271	let bitcount = dmx.src.read_u16le()?;
272	let compression = dmx.src.read_u32be()?;
273	let img_size = dmx.src.read_u32le()?;
274	let xdpi = dmx.src.read_u32le()?;
275	let ydpi = dmx.src.read_u32le()?;
276	let colors = dmx.src.read_u32le()?;
277	let imp_colors = dmx.src.read_u32le()?;
278
279	let flip = height < 0;
280	let format = if bitcount > 8 { RGB24_FORMAT } else { PAL8_FORMAT };
281	let vhdr = NAVideoInfo::new(width, if flip { -height as u32 } else { height as u32}, flip, PAL8_FORMAT);
282	let vci = NACodecTypeInfo::Video(vhdr);
283	let edata = dmx.read_extradata(size - 40)?;
284	let vinfo = NACodecInfo::new(vci, edata);
285	let res = dmx.dmx.add_stream(NAStream::new(StreamType::Video, dmx.sstate.strm_no as u32, vinfo));
286	if let None = res { return Err(MemoryError); }
287	dmx.sstate.reset();
288	Ok(size)
289	}
290
291	#[allow(unused_variables)]
292	fn parse_strf_auds(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
293	if size < 16 { return Err(InvalidData); }
294	let w_format_tag = dmx.src.read_u16le()?;
295	let channels = dmx.src.read_u16le()?;
296	let samplespersec = dmx.src.read_u32le()?;
297	let avgbytespersec = dmx.src.read_u32le()?;
298	let block_align = dmx.src.read_u16le()?;
299	let bits_per_sample = dmx.src.read_u16le()?;
300
301	let soniton = NASoniton::new(bits_per_sample as u8, SONITON_FLAG_SIGNED);
302	let ahdr = NAAudioInfo::new(samplespersec, channels as u8, soniton, block_align as usize);
303	let edata = dmx.read_extradata(size - 16)?;
304	let ainfo = NACodecInfo::new(NACodecTypeInfo::Audio(ahdr), edata);
305	let res = dmx.dmx.add_stream(NAStream::new(StreamType::Audio, dmx.sstate.strm_no as u32, ainfo));
306	if let None = res { return Err(MemoryError); }
307	dmx.sstate.reset();
308	Ok(size)
309	}
310
311	fn parse_strf_xxxx(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
312	let edata = dmx.read_extradata(size)?;
313	let info = NACodecInfo::new(NACodecTypeInfo::None, edata);
314	let res = dmx.dmx.add_stream(NAStream::new(StreamType::Data, dmx.sstate.strm_no as u32, info));
315	if let None = res { return Err(MemoryError); }
316	dmx.sstate.reset();
317	Ok(size)
318	}
319
320	#[allow(unused_variables)]
321	fn parse_avih(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
322	if size < 0x38 { return Err(InvalidData); }
323	let timebase = dmx.src.read_u32le()?; //microsec per frame
324	dmx.src.read_skip(4)?; //max frame size
325	dmx.src.read_skip(4)?; //padding
326	dmx.src.read_u32le()?; //flags
327	let frames = dmx.src.read_u32le()?; //frames
328	dmx.src.read_skip(4)?; //initial frames
329	let streams = dmx.src.read_u32le()?; //streams
330	if streams > 100 { return Err(InvalidData); }
331	dmx.num_streams = streams as u8;
332
333	dmx.src.read_skip(4)?; //buf size
334	let width = dmx.src.read_u32le()?; //width
335	let height = dmx.src.read_u32le()? as i32; //height
336	dmx.src.read_skip(16)?; //reserved
337
338	dmx.cur_frame.resize(streams as usize, 0);
339	dmx.src.read_skip(size - 0x38)?;
340	Ok(size)
341	}
342
343	fn parse_junk(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
344	dmx.src.read_skip(size)?;
345	Ok(size)
346	}
347
348	#[cfg(test)]
349	mod test {
350	use super::*;
351	use std::fs::File;
352
353	#[test]
354	fn test_avi_demux() {
355	let mut file = File::open("assets/laser05.avi").unwrap();
356	let mut fr = FileReader::new_read(&mut file);
357	let mut br = ByteReader::new(&mut fr);
358	let mut dmx = AVIDemuxer::new(&mut br);
359	dmx.open().unwrap();
360
361	loop {
362	let pktres = dmx.get_frame();
363	if let Err(e) = pktres {
364	if (e as i32) == (DemuxerError::EOF as i32) { break; }
365	panic!("error");
366	}
367	let pkt = pktres.unwrap();
368	println!("Got {}", pkt);
369	}
370	}
371	}