[nihav.git] / nihav-registry / src / detect.rs

//! Container format detection.
//!
//! Usually user does not know the container format of the opened file.
//! That is why format detection functionality is needed.
//! This module contains the set of rules to detect container not merely by file extension but also by its content if possible.
//!
//! # Examples
//!
//! ```no_run
//! use nihav_registry::detect::detect_format;
//! use std::fs::File;
//! use nihav_core::io::byteio::*;
//!
//! let name = "mediafile.ogv";
//! let mut file = File::open(name).unwrap();
//! let mut filereader = FileReader::new_read(&mut file);
//! let mut br = ByteReader::new(&mut filereader);
//! let result = detect_format(name, &mut br);
//! if let Some((name, score)) = result {
//!     println!("detected format {} with score {:?}", name, score);
//! }
//! ```
use std::io::SeekFrom;
use nihav_core::io::byteio::ByteReader;

/// Format detection score.
#[derive(Debug,Clone,Copy,PartialEq)]
pub enum DetectionScore {
    /// Format is not detected.
    No,
    /// Format matched by file extension.
    ExtensionMatches,
    /// Format matches by markers inside the file.
    MagicMatches,
}

impl DetectionScore {
    /// Checks whether current detection score is less than a value it is compared against.
    pub fn less(self, other: DetectionScore) -> bool {
        (self as i32) < (other as i32)
    }
}

#[allow(dead_code)]
enum Arg {
    Byte(u8),
    U16BE(u16),
    U16LE(u16),
    U24BE(u32),
    U24LE(u32),
    U32BE(u32),
    U32LE(u32),
    U64BE(u64),
    U64LE(u64),
}

impl Arg {
    fn val(&self) -> u64 {
        match *self {
            Arg::Byte(b) => { u64::from(b) }
            Arg::U16BE(v) => { u64::from(v) }
            Arg::U16LE(v) => { u64::from(v) }
            Arg::U24BE(v) => { u64::from(v) }
            Arg::U24LE(v) => { u64::from(v) }
            Arg::U32BE(v) => { u64::from(v) }
            Arg::U32LE(v) => { u64::from(v) }
            Arg::U64BE(v) => { v }
            Arg::U64LE(v) => { v }
        }
    }
    fn read_val(&self, src: &mut ByteReader) -> Option<u64> {
        match *self {
            Arg::Byte(_) => {
                let res = src.peek_byte();
                if res.is_err() { return None; }
                Some(u64::from(res.unwrap()))
            }
            Arg::U16BE(_) => {
                let res = src.peek_u16be();
                if res.is_err() { return None; }
                Some(u64::from(res.unwrap()))
            }
            Arg::U16LE(_) => {
                let res = src.peek_u16le();
                if res.is_err() { return None; }
                Some(u64::from(res.unwrap()))
            }
            Arg::U24BE(_) => {
                let res = src.peek_u24be();
                if res.is_err() { return None; }
                Some(u64::from(res.unwrap()))
            }
            Arg::U24LE(_) => {
                let res = src.peek_u24le();
                if res.is_err() { return None; }
                Some(u64::from(res.unwrap()))
            }
            Arg::U32BE(_) => {
                let res = src.peek_u32be();
                if res.is_err() { return None; }
                Some(u64::from(res.unwrap()))
            }
            Arg::U32LE(_) => {
                let res = src.peek_u32le();
                if res.is_err() { return None; }
                Some(u64::from(res.unwrap()))
            }
            Arg::U64BE(_) => {
                let res = src.peek_u64be();
                if res.is_err() { return None; }
                Some(res.unwrap())
            }
            Arg::U64LE(_) => {
                let res = src.peek_u64le();
                if res.is_err() { return None; }
                Some(res.unwrap())
            }
        }
    }
    fn eq(&self, src: &mut ByteReader) -> bool {
        if let Some(rval) = self.read_val(src) {
            rval == self.val()
        } else {
            false
        }
    }
    fn ge(&self, src: &mut ByteReader) -> bool {
        if let Some(rval) = self.read_val(src) {
            rval >= self.val()
        } else {
            false
        }
    }
    fn gt(&self, src: &mut ByteReader) -> bool {
        if let Some(rval) = self.read_val(src) {
            rval > self.val()
        } else {
            false
        }
    }
    fn le(&self, src: &mut ByteReader) -> bool {
        if let Some(rval) = self.read_val(src) {
            rval <= self.val()
        } else {
            false
        }
    }
    fn lt(&self, src: &mut ByteReader) -> bool {
        if let Some(rval) = self.read_val(src) {
            rval < self.val()
        } else {
            false
        }
    }
}

#[allow(dead_code)]
enum CC<'a> {
    Or(&'a CC<'a>, &'a CC<'a>),
    Eq(Arg),
    Str(&'static [u8]),
    In(Arg, Arg),
    Lt(Arg),
    Le(Arg),
    Gt(Arg),
    Ge(Arg),
}

impl<'a> CC<'a> {
    fn eval(&self, src: &mut ByteReader) -> bool {
        match *self {
            CC::Or (ref a, ref b) => { a.eval(src) || b.eval(src) },
            CC::Eq(ref arg)      => { arg.eq(src) },
            CC::In(ref a, ref b) => { a.ge(src) && b.le(src) },
            CC::Lt(ref arg)      => { arg.lt(src) },
            CC::Le(ref arg)      => { arg.le(src) },
            CC::Gt(ref arg)      => { arg.gt(src) },
            CC::Ge(ref arg)      => { arg.ge(src) },
            CC::Str(str) => {
                let mut val: Vec<u8> = vec![0; str.len()];
                let res = src.peek_buf(val.as_mut_slice());
                if res.is_err() { return false; }
                val == str
            }
        }
    }
}

struct CheckItem<'a> {
    offs: u32,
    cond: &'a CC<'a>,
}

#[allow(dead_code)]
struct DetectConditions<'a> {
    demux_name: &'static str,
    extensions: &'static str,
    conditions: &'a [CheckItem<'a>],
}

const DETECTORS: &[DetectConditions] = &[
    DetectConditions {
        demux_name: "avi",
        extensions: ".avi",
        conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::Str(b"RIFF"), &CC::Str(b"ON2 ")) },
                      CheckItem{offs: 8, cond: &CC::Or(&CC::Or(&CC::Str(b"AVI LIST"),
                                                               &CC::Str(b"AVIXLIST")),
                                                               &CC::Str(b"ON2fLIST")) },
                     ]
    },
    DetectConditions {
        demux_name: "wav",
        extensions: ".wav",
        conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"RIFF") },
                      CheckItem{offs: 8, cond: &CC::Str(b"WAVEfmt ") }
                     ]
    },
    DetectConditions {
        demux_name: "mov",
        extensions: ".mov",
        conditions: &[CheckItem{offs: 4, cond: &CC::Or(&CC::Or(&CC::Str(b"mdat"),
                                                               &CC::Str(b"moov")),
                                                               &CC::Str(b"ftyp")) }],
    },
    DetectConditions {
        demux_name: "mov",
        extensions: ".mov",
        conditions: &[CheckItem{offs:  0, cond: &CC::Str(b"\x00\x00\x00\x08wide") },
                      CheckItem{offs: 12, cond: &CC::Or(&CC::Or(&CC::Str(b"mdat"),
                                                                &CC::Str(b"moov")),
                                                                &CC::Str(b"ftyp")) }],
    },
    DetectConditions {
        demux_name: "yuv4mpeg",
        extensions: ".y4m",
        conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"YUV4MPEG2 ") }],
    },
    DetectConditions {
        demux_name: "fcmp",
        extensions: ".cmp",
        conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"FCMP")}],
    },
    DetectConditions {
        demux_name: "fst",
        extensions: ".fst",
        conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"2TSF")}],
    },
    DetectConditions {
        demux_name: "gdv",
        extensions: ".gdv",
        conditions: &[CheckItem{offs: 0, cond: &CC::Eq(Arg::U32LE(0x29111994))}],
    },
    DetectConditions {
        demux_name: "fable-imax",
        extensions: ".imx",
        conditions: &[CheckItem{offs:  0, cond: &CC::Str(b"IMAX") },
                      CheckItem{offs: 10, cond: &CC::Eq(Arg::U16LE(0x102)) }],
    },
    DetectConditions {
        demux_name: "legend-q",
        extensions: ".q",
        conditions: &[CheckItem{offs: 0, cond: &CC::Eq(Arg::U16LE(0x6839))},
                      CheckItem{offs: 2, cond: &CC::In(Arg::Byte(3), Arg::Byte(5))}],
    },
    DetectConditions {
        demux_name: "realaudio",
        extensions: ".ra,.ram",
        conditions: &[CheckItem{offs: 0, cond: &CC::Str(b".ra\xFD")}],
    },
    DetectConditions {
        demux_name: "realmedia",
        extensions: ".rm,.rmvb,.rma,.ra,.ram",
        conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::Str(b".RMF"), &CC::Str(b".RMP")) },
                      CheckItem{offs: 4, cond: &CC::Ge(Arg::U32BE(10))}],
    },
    DetectConditions {
        demux_name: "real_ivr",
        extensions: ".ivr",
        conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::Str(b".R1M"), &CC::Str(b".REC"))}],
    },
    DetectConditions {
        demux_name: "bink",
        extensions: ".bik,.bk2",
        conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::In(Arg::U32BE(0x42494B62),     // BIKb
                                                               Arg::U32BE(0x42494B7B)),    // BIKz
                                                       &CC::In(Arg::U32BE(0x4B423261),     // KB2a
                                                               Arg::U32BE(0x4B42327B)))}], // KB2z
    },
    DetectConditions {
        demux_name: "smacker",
        extensions: ".smk",
        conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::Str(b"SMK2"), &CC::Str(b"SMK4"))}],
    },
    DetectConditions {
        demux_name: "ape",
        extensions: ".ape",
        conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"MAC ") },
                      CheckItem{offs: 4, cond: &CC::In(Arg::U16LE(3800), Arg::U16LE(3990))}],
    },
    DetectConditions {
        demux_name: "flac",
        extensions: ".flac",
        conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"fLaC") }],
    },
    DetectConditions {
        demux_name: "tta",
        extensions: ".tta",
        conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"TTA1") }],
    },
    DetectConditions {
        demux_name: "wavpack",
        extensions: ".wv",
        conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"wvpk") },
                      CheckItem{offs: 8, cond: &CC::In(Arg::U16LE(0x402), Arg::U16LE(0x410))}],
    },
    DetectConditions {
        demux_name: "vivo",
        extensions: ".viv",
        conditions: &[CheckItem{offs: 0, cond: &CC::In(Arg::U16BE(1), Arg::U16BE(0xFF))},
                      CheckItem{offs: 2, cond: &CC::Str(b"\x0D\x0AVersion:Vivo/")}],
    },
    DetectConditions {
        demux_name: "vivo",
        extensions: ".viv",
        conditions: &[CheckItem{offs: 0, cond: &CC::In(Arg::U16BE(1), Arg::U16BE(0xFF))},
                      CheckItem{offs: 3, cond: &CC::Str(b"\x0D\x0AVersion:Vivo/")}],
    },
    DetectConditions {
        demux_name: "bmv",
        extensions: ".bmv",
        conditions: &[],
    },
    DetectConditions {
        demux_name: "bmv3",
        extensions: ".bmv",
        conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"BMVi") },
                      CheckItem{offs: 32, cond: &CC::Str(b"DATA")}],
    },
    DetectConditions {
        demux_name: "vmd",
        extensions: ".vmd",
        conditions: &[],
    },
    DetectConditions {
        demux_name: "vx",
        extensions: ".vx",
        conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"VXDS") }],
    },
];

/// Tries to detect container format.
///
/// This function tries to determine container format using both file extension and checking against container specific markers inside.
/// In case of success the function returns short container name and the detection score.
/// Result should have the highest detection score among tested.
pub fn detect_format(name: &str, src: &mut ByteReader) -> Option<(&'static str, DetectionScore)> {
    let mut result = None;
    let lname = name.to_lowercase();
    for detector in DETECTORS {
        let mut score = DetectionScore::No;
        if !name.is_empty() {
            for ext in detector.extensions.split(',') {
                if lname.ends_with(ext) {
                    score = DetectionScore::ExtensionMatches;
                    break;
                }
            }
        }
        let mut passed = !detector.conditions.is_empty();
        for ck in detector.conditions {
            let ret = src.seek(SeekFrom::Start(u64::from(ck.offs)));
            if ret.is_err() {
                passed = false;
                break;
            }
            if !ck.cond.eval(src) {
                passed = false;
                break;
            }
        }
        if passed {
            score = DetectionScore::MagicMatches;
        }
        if score == DetectionScore::MagicMatches {
            return Some((detector.demux_name, score));
        }
        if result.is_none() && score != DetectionScore::No {
            result = Some((detector.demux_name, score));
        } else if result.is_some() {
            let (_, oldsc) = result.unwrap();
            if oldsc.less(score) {
                result = Some((detector.demux_name, score));
            }
        }
    }
    result
}

/// Tries to detect container format for provided file name.
pub fn detect_format_by_name(name: &str) -> Option<&'static str> {
    if name.is_empty() {
        return None;
    }
    let lname = name.to_lowercase();
    for detector in DETECTORS {
        for ext in detector.extensions.split(',') {
            if lname.ends_with(ext) {
                return Some(detector.demux_name);
            }
        }
    }
    None
}

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

    #[test]
    fn test_avi_detect() {
        let name = "assets/Indeo/laser05.avi";
        let mut file = File::open(name).unwrap();
        let mut fr = FileReader::new_read(&mut file);
        let mut br = ByteReader::new(&mut fr);
        let (name, score) = detect_format(name, &mut br).unwrap();
        assert_eq!(name, "avi");
        assert_eq!(score, DetectionScore::MagicMatches);
    }

    #[test]
    fn test_gdv_detect() {
        let name = "assets/Game/intro1.gdv";
        let mut file = File::open(name).unwrap();
        let mut fr = FileReader::new_read(&mut file);
        let mut br = ByteReader::new(&mut fr);
        let (name, score) = detect_format(name, &mut br).unwrap();
        assert_eq!(name, "gdv");
        assert_eq!(score, DetectionScore::MagicMatches);
    }
}
Commit	Line	Data
1b5ebe1d KS	1	//! Container format detection.
	2	//!
	3	//! Usually user does not know the container format of the opened file.
	4	//! That is why format detection functionality is needed.
	5	//! This module contains the set of rules to detect container not merely by file extension but also by its content if possible.
	6	//!
	7	//! # Examples
	8	//!
	9	//! ```no_run
01f55c6a	10	//! use nihav_registry::detect::detect_format;
1b5ebe1d KS	11	//! use std::fs::File;
	12	//! use nihav_core::io::byteio::*;
	13	//!
	14	//! let name = "mediafile.ogv";
	15	//! let mut file = File::open(name).unwrap();
	16	//! let mut filereader = FileReader::new_read(&mut file);
	17	//! let mut br = ByteReader::new(&mut filereader);
	18	//! let result = detect_format(name, &mut br);
	19	//! if let Some((name, score)) = result {
	20	//! println!("detected format {} with score {:?}", name, score);
	21	//! }
	22	//! ```
d8ce0de0	23	use std::io::SeekFrom;
32f7cbe5	24	use nihav_core::io::byteio::ByteReader;
d8ce0de0	25
1b5ebe1d	26	/// Format detection score.
d8ce0de0 KS	27	#[derive(Debug,Clone,Copy,PartialEq)]
d8ce0de0 KS	28	pub enum DetectionScore {
1b5ebe1d	29	/// Format is not detected.
d8ce0de0	30	No,
1b5ebe1d	31	/// Format matched by file extension.
d8ce0de0	32	ExtensionMatches,
1b5ebe1d	33	/// Format matches by markers inside the file.
d8ce0de0 KS	34	MagicMatches,
	35	}
	36
	37	impl DetectionScore {
1b5ebe1d	38	/// Checks whether current detection score is less than a value it is compared against.
e243ceb4 KS	39	pub fn less(self, other: DetectionScore) -> bool {
e243ceb4 KS	40	(self as i32) < (other as i32)
d8ce0de0 KS	41	}
	42	}
	43
	44	#[allow(dead_code)]
b5bd2ae4	45	enum Arg {
d8ce0de0 KS	46	Byte(u8),
	47	U16BE(u16),
	48	U16LE(u16),
	49	U24BE(u32),
	50	U24LE(u32),
	51	U32BE(u32),
	52	U32LE(u32),
	53	U64BE(u64),
	54	U64LE(u64),
	55	}
	56
b5bd2ae4	57	impl Arg {
d8ce0de0 KS	58	fn val(&self) -> u64 {
d8ce0de0 KS	59	match *self {
e243ceb4 KS	60	Arg::Byte(b) => { u64::from(b) }
	61	Arg::U16BE(v) => { u64::from(v) }
	62	Arg::U16LE(v) => { u64::from(v) }
	63	Arg::U24BE(v) => { u64::from(v) }
	64	Arg::U24LE(v) => { u64::from(v) }
	65	Arg::U32BE(v) => { u64::from(v) }
	66	Arg::U32LE(v) => { u64::from(v) }
b5bd2ae4 KS	67	Arg::U64BE(v) => { v }
b5bd2ae4 KS	68	Arg::U64LE(v) => { v }
d8ce0de0 KS	69	}
	70	}
	71	fn read_val(&self, src: &mut ByteReader) -> Option<u64> {
	72	match *self {
b5bd2ae4	73	Arg::Byte(_) => {
d8ce0de0	74	let res = src.peek_byte();
e243ceb4 KS	75	if res.is_err() { return None; }
e243ceb4 KS	76	Some(u64::from(res.unwrap()))
d8ce0de0	77	}
b5bd2ae4	78	Arg::U16BE(_) => {
d8ce0de0	79	let res = src.peek_u16be();
e243ceb4 KS	80	if res.is_err() { return None; }
e243ceb4 KS	81	Some(u64::from(res.unwrap()))
d8ce0de0	82	}
b5bd2ae4	83	Arg::U16LE(_) => {
d8ce0de0	84	let res = src.peek_u16le();
e243ceb4 KS	85	if res.is_err() { return None; }
e243ceb4 KS	86	Some(u64::from(res.unwrap()))
d8ce0de0	87	}
b5bd2ae4	88	Arg::U24BE(_) => {
d8ce0de0	89	let res = src.peek_u24be();
e243ceb4 KS	90	if res.is_err() { return None; }
e243ceb4 KS	91	Some(u64::from(res.unwrap()))
d8ce0de0	92	}
b5bd2ae4	93	Arg::U24LE(_) => {
d8ce0de0	94	let res = src.peek_u24le();
e243ceb4 KS	95	if res.is_err() { return None; }
e243ceb4 KS	96	Some(u64::from(res.unwrap()))
d8ce0de0	97	}
b5bd2ae4	98	Arg::U32BE(_) => {
d8ce0de0	99	let res = src.peek_u32be();
e243ceb4 KS	100	if res.is_err() { return None; }
e243ceb4 KS	101	Some(u64::from(res.unwrap()))
d8ce0de0	102	}
b5bd2ae4	103	Arg::U32LE(_) => {
d8ce0de0	104	let res = src.peek_u32le();
e243ceb4 KS	105	if res.is_err() { return None; }
e243ceb4 KS	106	Some(u64::from(res.unwrap()))
d8ce0de0	107	}
b5bd2ae4	108	Arg::U64BE(_) => {
d8ce0de0	109	let res = src.peek_u64be();
e243ceb4	110	if res.is_err() { return None; }
d8ce0de0 KS	111	Some(res.unwrap())
d8ce0de0 KS	112	}
b5bd2ae4	113	Arg::U64LE(_) => {
d8ce0de0	114	let res = src.peek_u64le();
e243ceb4	115	if res.is_err() { return None; }
d8ce0de0 KS	116	Some(res.unwrap())
	117	}
	118	}
	119	}
	120	fn eq(&self, src: &mut ByteReader) -> bool {
01f55c6a KS	121	if let Some(rval) = self.read_val(src) {
	122	rval == self.val()
	123	} else {
	124	false
	125	}
d8ce0de0 KS	126	}
d8ce0de0 KS	127	fn ge(&self, src: &mut ByteReader) -> bool {
01f55c6a KS	128	if let Some(rval) = self.read_val(src) {
	129	rval >= self.val()
	130	} else {
	131	false
	132	}
d8ce0de0 KS	133	}
d8ce0de0 KS	134	fn gt(&self, src: &mut ByteReader) -> bool {
01f55c6a KS	135	if let Some(rval) = self.read_val(src) {
	136	rval > self.val()
	137	} else {
	138	false
	139	}
d8ce0de0 KS	140	}
d8ce0de0 KS	141	fn le(&self, src: &mut ByteReader) -> bool {
01f55c6a KS	142	if let Some(rval) = self.read_val(src) {
	143	rval <= self.val()
	144	} else {
	145	false
	146	}
d8ce0de0 KS	147	}
d8ce0de0 KS	148	fn lt(&self, src: &mut ByteReader) -> bool {
01f55c6a KS	149	if let Some(rval) = self.read_val(src) {
	150	rval < self.val()
	151	} else {
	152	false
	153	}
d8ce0de0 KS	154	}
	155	}
	156
	157	#[allow(dead_code)]
b5bd2ae4 KS	158	enum CC<'a> {
	159	Or(&'a CC<'a>, &'a CC<'a>),
	160	Eq(Arg),
	161	Str(&'static [u8]),
	162	In(Arg, Arg),
	163	Lt(Arg),
	164	Le(Arg),
	165	Gt(Arg),
	166	Ge(Arg),
d8ce0de0 KS	167	}
d8ce0de0 KS	168
b5bd2ae4	169	impl<'a> CC<'a> {
d8ce0de0 KS	170	fn eval(&self, src: &mut ByteReader) -> bool {
d8ce0de0 KS	171	match *self {
b5bd2ae4 KS	172	CC::Or (ref a, ref b) => { a.eval(src) \|\| b.eval(src) },
b5bd2ae4 KS	173	CC::Eq(ref arg) => { arg.eq(src) },
4d477e23	174	CC::In(ref a, ref b) => { a.ge(src) && b.le(src) },
b5bd2ae4 KS	175	CC::Lt(ref arg) => { arg.lt(src) },
	176	CC::Le(ref arg) => { arg.le(src) },
	177	CC::Gt(ref arg) => { arg.gt(src) },
	178	CC::Ge(ref arg) => { arg.ge(src) },
	179	CC::Str(str) => {
e243ceb4	180	let mut val: Vec<u8> = vec![0; str.len()];
d8ce0de0	181	let res = src.peek_buf(val.as_mut_slice());
e243ceb4	182	if res.is_err() { return false; }
d8ce0de0 KS	183	val == str
	184	}
	185	}
	186	}
	187	}
	188
	189	struct CheckItem<'a> {
	190	offs: u32,
b5bd2ae4	191	cond: &'a CC<'a>,
d8ce0de0 KS	192	}
	193
	194	#[allow(dead_code)]
	195	struct DetectConditions<'a> {
	196	demux_name: &'static str,
	197	extensions: &'static str,
	198	conditions: &'a [CheckItem<'a>],
	199	}
	200
	201	const DETECTORS: &[DetectConditions] = &[
	202	DetectConditions {
	203	demux_name: "avi",
	204	extensions: ".avi",
b5bd2ae4 KS	205	conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::Str(b"RIFF"), &CC::Str(b"ON2 ")) },
	206	CheckItem{offs: 8, cond: &CC::Or(&CC::Or(&CC::Str(b"AVI LIST"),
	207	&CC::Str(b"AVIXLIST")),
	208	&CC::Str(b"ON2fLIST")) },
	209	]
d8ce0de0	210	},
283abfa6 KS	211	DetectConditions {
	212	demux_name: "wav",
	213	extensions: ".wav",
	214	conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"RIFF") },
	215	CheckItem{offs: 8, cond: &CC::Str(b"WAVEfmt ") }
	216	]
	217	},
bdf66deb KS	218	DetectConditions {
	219	demux_name: "mov",
	220	extensions: ".mov",
	221	conditions: &[CheckItem{offs: 4, cond: &CC::Or(&CC::Or(&CC::Str(b"mdat"),
	222	&CC::Str(b"moov")),
	223	&CC::Str(b"ftyp")) }],
	224	},
	225	DetectConditions {
	226	demux_name: "mov",
	227	extensions: ".mov",
	228	conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"\x00\x00\x00\x08wide") },
	229	CheckItem{offs: 12, cond: &CC::Or(&CC::Or(&CC::Str(b"mdat"),
	230	&CC::Str(b"moov")),
	231	&CC::Str(b"ftyp")) }],
	232	},
dbb2cbc9 KS	233	DetectConditions {
	234	demux_name: "yuv4mpeg",
	235	extensions: ".y4m",
	236	conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"YUV4MPEG2 ") }],
	237	},
8d91d85f KS	238	DetectConditions {
	239	demux_name: "fcmp",
	240	extensions: ".cmp",
	241	conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"FCMP")}],
	242	},
	243	DetectConditions {
	244	demux_name: "fst",
	245	extensions: ".fst",
	246	conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"2TSF")}],
	247	},
d8ce0de0 KS	248	DetectConditions {
	249	demux_name: "gdv",
	250	extensions: ".gdv",
b5bd2ae4	251	conditions: &[CheckItem{offs: 0, cond: &CC::Eq(Arg::U32LE(0x29111994))}],
d8ce0de0	252	},
3813fe8a KS	253	DetectConditions {
	254	demux_name: "fable-imax",
	255	extensions: ".imx",
	256	conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"IMAX") },
	257	CheckItem{offs: 10, cond: &CC::Eq(Arg::U16LE(0x102)) }],
	258	},
afe1e5ba KS	259	DetectConditions {
	260	demux_name: "legend-q",
	261	extensions: ".q",
	262	conditions: &[CheckItem{offs: 0, cond: &CC::Eq(Arg::U16LE(0x6839))},
	263	CheckItem{offs: 2, cond: &CC::In(Arg::Byte(3), Arg::Byte(5))}],
	264	},
ce52b3b5 KS	265	DetectConditions {
	266	demux_name: "realaudio",
	267	extensions: ".ra,.ram",
	268	conditions: &[CheckItem{offs: 0, cond: &CC::Str(b".ra\xFD")}],
	269	},
	270	DetectConditions {
	271	demux_name: "realmedia",
	272	extensions: ".rm,.rmvb,.rma,.ra,.ram",
db5cc44b	273	conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::Str(b".RMF"), &CC::Str(b".RMP")) },
ce52b3b5 KS	274	CheckItem{offs: 4, cond: &CC::Ge(Arg::U32BE(10))}],
	275	},
	276	DetectConditions {
	277	demux_name: "real_ivr",
	278	extensions: ".ivr",
	279	conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::Str(b".R1M"), &CC::Str(b".REC"))}],
	280	},
c6c21059 KS	281	DetectConditions {
c6c21059 KS	282	demux_name: "bink",
4d477e23	283	extensions: ".bik,.bk2",
4998874b KS	284	conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::In(Arg::U32BE(0x42494B62), // BIKb
4998874b KS	285	Arg::U32BE(0x42494B7B)), // BIKz
c6c21059 KS	286	&CC::In(Arg::U32BE(0x4B423261), // KB2a
	287	Arg::U32BE(0x4B42327B)))}], // KB2z
	288	},
606c448e KS	289	DetectConditions {
	290	demux_name: "smacker",
	291	extensions: ".smk",
	292	conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::Str(b"SMK2"), &CC::Str(b"SMK4"))}],
	293	},
87927c57 KS	294	DetectConditions {
	295	demux_name: "ape",
	296	extensions: ".ape",
	297	conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"MAC ") },
	298	CheckItem{offs: 4, cond: &CC::In(Arg::U16LE(3800), Arg::U16LE(3990))}],
	299	},
	300	DetectConditions {
	301	demux_name: "flac",
	302	extensions: ".flac",
	303	conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"fLaC") }],
	304	},
	305	DetectConditions {
	306	demux_name: "tta",
	307	extensions: ".tta",
	308	conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"TTA1") }],
	309	},
	310	DetectConditions {
	311	demux_name: "wavpack",
	312	extensions: ".wv",
	313	conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"wvpk") },
	314	CheckItem{offs: 8, cond: &CC::In(Arg::U16LE(0x402), Arg::U16LE(0x410))}],
	315	},
128253cc	316	DetectConditions {
31cf33ac KS	317	demux_name: "vivo",
	318	extensions: ".viv",
	319	conditions: &[CheckItem{offs: 0, cond: &CC::In(Arg::U16BE(1), Arg::U16BE(0xFF))},
	320	CheckItem{offs: 2, cond: &CC::Str(b"\x0D\x0AVersion:Vivo/")}],
	321	},
	322	DetectConditions {
	323	demux_name: "vivo",
	324	extensions: ".viv",
	325	conditions: &[CheckItem{offs: 0, cond: &CC::In(Arg::U16BE(1), Arg::U16BE(0xFF))},
	326	CheckItem{offs: 3, cond: &CC::Str(b"\x0D\x0AVersion:Vivo/")}],
	327	},
	328	DetectConditions {
128253cc KS	329	demux_name: "bmv",
	330	extensions: ".bmv",
	331	conditions: &[],
	332	},
ecda1cc1 KS	333	DetectConditions {
	334	demux_name: "bmv3",
	335	extensions: ".bmv",
	336	conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"BMVi") },
	337	CheckItem{offs: 32, cond: &CC::Str(b"DATA")}],
	338	},
9895bd7b KS	339	DetectConditions {
	340	demux_name: "vmd",
	341	extensions: ".vmd",
	342	conditions: &[],
	343	},
55d85231 KS	344	DetectConditions {
	345	demux_name: "vx",
	346	extensions: ".vx",
	347	conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"VXDS") }],
	348	},
d8ce0de0 KS	349	];
d8ce0de0 KS	350
1b5ebe1d KS	351	/// Tries to detect container format.
	352	///
	353	/// This function tries to determine container format using both file extension and checking against container specific markers inside.
	354	/// In case of success the function returns short container name and the detection score.
	355	/// Result should have the highest detection score among tested.
d8ce0de0 KS	356	pub fn detect_format(name: &str, src: &mut ByteReader) -> Option<(&'static str, DetectionScore)> {
	357	let mut result = None;
	358	let lname = name.to_lowercase();
	359	for detector in DETECTORS {
	360	let mut score = DetectionScore::No;
e243ceb4	361	if !name.is_empty() {
d8ce0de0 KS	362	for ext in detector.extensions.split(',') {
	363	if lname.ends_with(ext) {
	364	score = DetectionScore::ExtensionMatches;
	365	break;
	366	}
	367	}
	368	}
e243ceb4	369	let mut passed = !detector.conditions.is_empty();
d8ce0de0	370	for ck in detector.conditions {
e243ceb4 KS	371	let ret = src.seek(SeekFrom::Start(u64::from(ck.offs)));
e243ceb4 KS	372	if ret.is_err() {
d8ce0de0 KS	373	passed = false;
	374	break;
	375	}
	376	if !ck.cond.eval(src) {
	377	passed = false;
	378	break;
	379	}
	380	}
	381	if passed {
	382	score = DetectionScore::MagicMatches;
	383	}
	384	if score == DetectionScore::MagicMatches {
	385	return Some((detector.demux_name, score));
	386	}
4d477e23	387	if result.is_none() && score != DetectionScore::No {
d8ce0de0	388	result = Some((detector.demux_name, score));
4d477e23	389	} else if result.is_some() {
d8ce0de0 KS	390	let (_, oldsc) = result.unwrap();
	391	if oldsc.less(score) {
	392	result = Some((detector.demux_name, score));
	393	}
	394	}
	395	}
	396	result
	397	}
	398
4b56e8c9	399	/// Tries to detect container format for provided file name.
ac818eac	400	pub fn detect_format_by_name(name: &str) -> Option<&'static str> {
4b56e8c9 KS	401	if name.is_empty() {
	402	return None;
	403	}
	404	let lname = name.to_lowercase();
	405	for detector in DETECTORS {
	406	for ext in detector.extensions.split(',') {
	407	if lname.ends_with(ext) {
	408	return Some(detector.demux_name);
	409	}
	410	}
	411	}
	412	None
	413	}
	414
d8ce0de0 KS	415	#[cfg(test)]
	416	mod test {
	417	use super::*;
	418	use std::fs::File;
01f55c6a	419	use nihav_core::io::byteio::*;
d8ce0de0 KS	420
	421	#[test]
	422	fn test_avi_detect() {
250c49f6	423	let name = "assets/Indeo/laser05.avi";
d8ce0de0 KS	424	let mut file = File::open(name).unwrap();
	425	let mut fr = FileReader::new_read(&mut file);
	426	let mut br = ByteReader::new(&mut fr);
	427	let (name, score) = detect_format(name, &mut br).unwrap();
	428	assert_eq!(name, "avi");
	429	assert_eq!(score, DetectionScore::MagicMatches);
	430	}
	431
	432	#[test]
	433	fn test_gdv_detect() {
250c49f6	434	let name = "assets/Game/intro1.gdv";
d8ce0de0 KS	435	let mut file = File::open(name).unwrap();
	436	let mut fr = FileReader::new_read(&mut file);
	437	let mut br = ByteReader::new(&mut fr);
	438	let (name, score) = detect_format(name, &mut br).unwrap();
	439	assert_eq!(name, "gdv");
	440	assert_eq!(score, DetectionScore::MagicMatches);
	441	}
b5bd2ae4	442	}