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

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