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

use nihav_core::demuxers::*;
use nihav_core::register;
use nihav_core::demuxers::DemuxerError::*;

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)]
struct AVIDemuxer<'a> {
    src:            &'a mut ByteReader<'a>,
    cur_frame:      Vec<u64>,
    num_streams:    u8,
    size:           usize,
    movi_size:      usize,
    sstate:         StreamState,
    tb_num:         u32,
    tb_den:         u32,
}

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

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

impl<'a> DemuxCore<'a> for AVIDemuxer<'a> {
    #[allow(unused_variables)]
    fn open(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
        self.read_header(strmgr)?;
        Ok(())
    }

    fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
        if self.movi_size == 0 { return Err(EOF); }
        let mut tag: [u8; 4] = [0; 4];
        loop {
            if (self.src.tell() & 1) == 1 {
                self.src.read_skip(1)?;
                self.movi_size -= 1;
                if self.movi_size == 0 { return Err(EOF); }
            }
            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)?;
                if self.movi_size == 0 { return Err(EOF); }
                continue;
            }
            if mktag!(tag) == mktag!(b"LIST") {
                self.movi_size -= 12;
                self.src.read_skip(4)?;
                if self.movi_size == 0 { return Err(EOF); }
                continue;
            }
            if tag[0] == b'i' && tag[1] == b'x' {
                return Err(EOF);
            }
            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 = strmgr.get_stream(stream_no as usize);
            if str.is_none() { return Err(InvalidData); }
            let stream = str.unwrap();
            if size == 0 {
                self.movi_size -= 8;
                if self.movi_size == 0 { return Err(EOF); }
                continue;
            }
            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;

            return Ok(pkt);
        }
    }

    #[allow(unused_variables)]
    fn seek(&mut self, time: u64) -> DemuxerResult<()> {
        Err(NotImplemented)
    }
}

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

    fn parse_chunk(&mut self, strmgr: &mut StreamManager, 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 is_list = is_list_tag(tag);
        let ltag = if is_list { self.src.read_u32be()? } else { 0 };
        if RIFFTag::List(tag, ltag) == end_tag {
            return Ok((size, true));
        }

        for chunk in CHUNKS.iter() {
            if RIFFTag::Chunk(tag) == chunk.tag {
                let psize = (chunk.parse)(self, strmgr, size)?;
                if psize != size { return Err(InvalidData); }
                if (psize & 1) == 1 { self.src.read_skip(1)?; }
                return Ok((size + 8, false));
            }
            if RIFFTag::List(tag, ltag) == chunk.tag {
                let mut rest_size = size - 4;
                let psize = (chunk.parse)(self, strmgr, rest_size)?;
                if psize > rest_size { return Err(InvalidData); }
                rest_size -= psize;
                while rest_size > 0 {
                    let (psize, _) = self.parse_chunk(strmgr, end_tag, rest_size, depth+1)?;
                    if psize > rest_size { return Err(InvalidData); }
                    rest_size -= psize;
                    if ((psize & 1) == 1) && (rest_size > 0) {
                        rest_size -= 1;
                    }
                }

                return Ok((size + 8, false));
            }
        }
        if !is_list {
            self.src.read_skip(size)?;
        } else {
            if size < 4 { return Err(InvalidData); }
            self.src.read_skip(size - 4)?;
        }
        if (size & 1) == 1 { self.src.read_skip(1)?; }
        Ok((size + 8, false))
    }

    fn read_header(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
        let riff_tag = self.src.read_u32be()?;
        let size     = self.src.read_u32le()? as usize;
        let avi_tag  = self.src.read_u32be()?;
        let mut matches = false;
        for rt in RIFF_TAGS.iter() {
            if rt[0] == riff_tag && rt[1] == avi_tag {
                matches = true;
                break;
            }
        }
        if !matches {
            return Err(InvalidData);
        }
        self.size = size;
        let mut rest_size = size;
        loop {
            let (csz, end) = self.parse_chunk(strmgr, 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![0; size];
        self.src.read_buf(&mut edvec)?;
        Ok(Some(edvec))
    }
}

const RIFF_TAGS: &[[u32; 2]] = &[
    [ mktag!(b"RIFF"), mktag!(b"AVI ") ],
    [ mktag!(b"RIFF"), mktag!(b"AVIX") ],
    [ mktag!(b"ON2 "), mktag!(b"ON2f") ],
];

const CHUNKS: [RIFFParser; 7] = [
    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"ON2h")), 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 chunk in CHUNKS.iter() {
        if let RIFFTag::List(ltag, _) = chunk.tag {
            if tag == ltag {
                return true;
            }
        }
    }
    false
}

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

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

#[allow(unused_variables)]
fn parse_strh(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, 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
    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
    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, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
    if dmx.sstate.strm_type.is_none() { return Err(InvalidData); }
    match dmx.sstate.strm_type.unwrap() {
        StreamType::Video    => parse_strf_vids(dmx, strmgr, size),
        StreamType::Audio    => parse_strf_auds(dmx, strmgr, size),
        _                    => parse_strf_xxxx(dmx, strmgr, size),
    }
}

#[allow(unused_variables)]
fn parse_strf_vids(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, 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 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 cname = match register::find_codec_from_avi_fourcc(&compression) {
                    None => "unknown",
                    Some(name) => name,
                };
    let vinfo = NACodecInfo::new(cname, vci, edata);
    let res = strmgr.add_stream(NAStream::new(StreamType::Video, u32::from(dmx.sstate.strm_no), vinfo, dmx.tb_num, dmx.tb_den));
    if res.is_none() { return Err(MemoryError); }
    dmx.sstate.reset();
    Ok(size)
}

#[allow(unused_variables)]
fn parse_strf_auds(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, 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()? * 8;

    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 = strmgr.add_stream(NAStream::new(StreamType::Audio, u32::from(dmx.sstate.strm_no), ainfo, dmx.tb_num, dmx.tb_den));
    if res.is_none() { return Err(MemoryError); }
    dmx.sstate.reset();
    Ok(size)
}

fn parse_strf_xxxx(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
    let edata = dmx.read_extradata(size)?;
    let info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata);
    let res = strmgr.add_stream(NAStream::new(StreamType::Data, u32::from(dmx.sstate.strm_no), info, dmx.tb_num, dmx.tb_den));
    if res.is_none() { return Err(MemoryError); }
    dmx.sstate.reset();
    Ok(size)
}

#[allow(unused_variables)]
fn parse_avih(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, 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)
}

#[allow(unused_variables)]
fn parse_junk(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
    dmx.src.read_skip(size)?;
    Ok(size)
}

pub struct AVIDemuxerCreator { }

impl DemuxerCreator for AVIDemuxerCreator {
    fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
        Box::new(AVIDemuxer::new(br))
    }
    fn get_name(&self) -> &'static str { "avi" }
}

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

    #[test]
    fn test_avi_demux() {
        let mut file = File::open("assets/Indeo/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);
        let mut sm = StreamManager::new();
        dmx.open(&mut sm).unwrap();

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