1 //! Container format detection.
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.
10 //! use nihav_registry::detect::detect_format;
11 //! use std::fs::File;
12 //! use nihav_core::io::byteio::*;
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);
23 use std::io::SeekFrom;
24 use nihav_core::io::byteio::ByteReader;
26 /// Format detection score.
27 #[derive(Debug,Clone,Copy,PartialEq)]
28 pub enum DetectionScore {
29 /// Format is not detected.
31 /// Format matched by file extension.
33 /// Format matches by markers inside the file.
38 /// Checks whether current detection score is less than a value it is compared against.
39 pub fn less(self, other: DetectionScore) -> bool {
40 (self as i32) < (other as i32)
58 fn val(&self) -> u64 {
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) }
67 Arg::U64BE(v) => { v }
68 Arg::U64LE(v) => { v }
71 fn read_val(&self, src: &mut ByteReader) -> Option<u64> {
74 let res = src.peek_byte();
75 if res.is_err() { return None; }
76 Some(u64::from(res.unwrap()))
79 let res = src.peek_u16be();
80 if res.is_err() { return None; }
81 Some(u64::from(res.unwrap()))
84 let res = src.peek_u16le();
85 if res.is_err() { return None; }
86 Some(u64::from(res.unwrap()))
89 let res = src.peek_u24be();
90 if res.is_err() { return None; }
91 Some(u64::from(res.unwrap()))
94 let res = src.peek_u24le();
95 if res.is_err() { return None; }
96 Some(u64::from(res.unwrap()))
99 let res = src.peek_u32be();
100 if res.is_err() { return None; }
101 Some(u64::from(res.unwrap()))
104 let res = src.peek_u32le();
105 if res.is_err() { return None; }
106 Some(u64::from(res.unwrap()))
109 let res = src.peek_u64be();
110 if res.is_err() { return None; }
114 let res = src.peek_u64le();
115 if res.is_err() { return None; }
120 fn eq(&self, src: &mut ByteReader) -> bool {
121 if let Some(rval) = self.read_val(src) {
127 fn ge(&self, src: &mut ByteReader) -> bool {
128 if let Some(rval) = self.read_val(src) {
134 fn gt(&self, src: &mut ByteReader) -> bool {
135 if let Some(rval) = self.read_val(src) {
141 fn le(&self, src: &mut ByteReader) -> bool {
142 if let Some(rval) = self.read_val(src) {
148 fn lt(&self, src: &mut ByteReader) -> bool {
149 if let Some(rval) = self.read_val(src) {
159 Or(&'a CC<'a>, &'a CC<'a>),
170 fn eval(&self, src: &mut ByteReader) -> bool {
172 CC::Or(a, b) => { a.eval(src) || b.eval(src) },
173 CC::Eq(ref arg) => { arg.eq(src) },
174 CC::In(ref a, ref b) => { a.ge(src) && b.le(src) },
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) },
180 let mut val: Vec<u8> = vec![0; str.len()];
181 let res = src.peek_buf(val.as_mut_slice());
182 if res.is_err() { return false; }
189 struct CheckItem<'a> {
195 struct DetectConditions<'a> {
196 demux_name: &'static str,
197 extensions: &'static str,
198 conditions: &'a [CheckItem<'a>],
201 const DETECTORS: &[DetectConditions] = &[
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")) },
214 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"RIFF") },
215 CheckItem{offs: 8, cond: &CC::Str(b"WAVEfmt ") }
221 conditions: &[CheckItem{offs: 4, cond: &CC::Or(&CC::Or(&CC::Str(b"mdat"),
223 &CC::Str(b"ftyp")) }],
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"),
231 &CC::Str(b"ftyp")) }],
234 demux_name: "yuv4mpeg",
236 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"YUV4MPEG2 ") }],
241 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"FLV") },
242 CheckItem{offs: 3, cond: &CC::Le(Arg::Byte(1)) }],
247 conditions: &[CheckItem{offs: 0, cond: &CC::Str(&[0x50, 0xEF, 0x81, 0x19, 0xB3, 0xBD, 0xD0, 0x11, 0xA3, 0xE5, 0x00, 0xA0, 0xC9, 0x24, 0x44])},
248 CheckItem{offs: 15, cond: &CC::Or(&CC::Eq(Arg::Byte(0x36)), &CC::Eq(Arg::Byte(0x37)))}],
253 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"DKIF\x00\x00")},
254 CheckItem{offs: 6, cond: &CC::Ge(Arg::U16LE(32))}],
259 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"FCMP")}],
264 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"2TSF")}],
269 conditions: &[CheckItem{offs: 0, cond: &CC::Eq(Arg::U32LE(0x29111994))}],
272 demux_name: "fable-imax",
274 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"IMAX") },
275 CheckItem{offs: 10, cond: &CC::Eq(Arg::U16LE(0x102)) }],
278 demux_name: "hl-fmv",
280 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"FMV*") },
281 CheckItem{offs: 4, cond: &CC::Eq(Arg::U32LE(0)) }],
284 demux_name: "legend-q",
286 conditions: &[CheckItem{offs: 0, cond: &CC::Eq(Arg::U16LE(0x6839))},
287 CheckItem{offs: 2, cond: &CC::In(Arg::Byte(3), Arg::Byte(7))}],
292 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"ANIM")},
293 CheckItem{offs: 8, cond: &CC::Str(b"AHDR")}],
296 demux_name: "smush-mcmp",
298 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"MCMP")},
299 CheckItem{offs: 6, cond: &CC::Eq(Arg::Byte(0))},
300 CheckItem{offs: 7, cond: &CC::Eq(Arg::Byte(0))}],
305 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"SANM")},
306 CheckItem{offs: 8, cond: &CC::Str(b"SHDR")}],
309 demux_name: "realaudio",
310 extensions: ".ra,.ram",
311 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b".ra\xFD")}],
314 demux_name: "realmedia",
315 extensions: ".rm,.rmvb,.rma,.ra,.ram",
316 conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::Str(b".RMF"), &CC::Str(b".RMP")) },
317 CheckItem{offs: 4, cond: &CC::Ge(Arg::U32BE(10))}],
320 demux_name: "real_ivr",
322 conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::Str(b".R1M"), &CC::Str(b".REC"))}],
326 extensions: ".bik,.bk2",
327 conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::In(Arg::U32BE(0x42494B62), // BIKb
328 Arg::U32BE(0x42494B7B)), // BIKz
329 &CC::In(Arg::U32BE(0x4B423261), // KB2a
330 Arg::U32BE(0x4B42327B)))}], // KB2z
333 demux_name: "smacker",
335 conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::Str(b"SMK2"), &CC::Str(b"SMK4"))}],
340 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"MAC ") },
341 CheckItem{offs: 4, cond: &CC::In(Arg::U16LE(3800), Arg::U16LE(3990))}],
346 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"fLaC") }],
351 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"TTA1") }],
354 demux_name: "wavpack",
356 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"wvpk") },
357 CheckItem{offs: 8, cond: &CC::In(Arg::U16LE(0x402), Arg::U16LE(0x410))}],
362 conditions: &[CheckItem{offs: 0, cond: &CC::In(Arg::U16BE(1), Arg::U16BE(0xFF))},
363 CheckItem{offs: 2, cond: &CC::Str(b"\x0D\x0AVersion:Vivo/")}],
368 conditions: &[CheckItem{offs: 0, cond: &CC::In(Arg::U16BE(1), Arg::U16BE(0xFF))},
369 CheckItem{offs: 3, cond: &CC::Str(b"\x0D\x0AVersion:Vivo/")}],
379 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"BMVi") },
380 CheckItem{offs: 32, cond: &CC::Str(b"DATA")}],
390 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b"VXDS") }],
394 /// Tries to detect container format.
396 /// This function tries to determine container format using both file extension and checking against container specific markers inside.
397 /// In case of success the function returns short container name and the detection score.
398 /// Result should have the highest detection score among tested.
399 pub fn detect_format(name: &str, src: &mut ByteReader) -> Option<(&'static str, DetectionScore)> {
400 let mut result = None;
401 let lname = name.to_lowercase();
402 for detector in DETECTORS {
403 let mut score = DetectionScore::No;
404 if !name.is_empty() {
405 for ext in detector.extensions.split(',') {
406 if lname.ends_with(ext) {
407 score = DetectionScore::ExtensionMatches;
412 let mut passed = !detector.conditions.is_empty();
413 for ck in detector.conditions {
414 let ret = src.seek(SeekFrom::Start(u64::from(ck.offs)));
419 if !ck.cond.eval(src) {
425 score = DetectionScore::MagicMatches;
427 if score == DetectionScore::MagicMatches {
428 return Some((detector.demux_name, score));
430 if result.is_none() && score != DetectionScore::No {
431 result = Some((detector.demux_name, score));
432 } else if result.is_some() {
433 let (_, oldsc) = result.unwrap();
434 if oldsc.less(score) {
435 result = Some((detector.demux_name, score));
442 /// Tries to detect container format for provided file name.
443 pub fn detect_format_by_name(name: &str) -> Option<&'static str> {
447 let lname = name.to_lowercase();
448 for detector in DETECTORS {
449 for ext in detector.extensions.split(',') {
450 if lname.ends_with(ext) {
451 return Some(detector.demux_name);
462 use nihav_core::io::byteio::*;
465 fn test_avi_detect() {
466 let name = "assets/Indeo/laser05.avi";
467 let mut file = File::open(name).unwrap();
468 let mut fr = FileReader::new_read(&mut file);
469 let mut br = ByteReader::new(&mut fr);
470 let (name, score) = detect_format(name, &mut br).unwrap();
471 assert_eq!(name, "avi");
472 assert_eq!(score, DetectionScore::MagicMatches);
476 fn test_gdv_detect() {
477 let name = "assets/Game/intro1.gdv";
478 let mut file = File::open(name).unwrap();
479 let mut fr = FileReader::new_read(&mut file);
480 let mut br = ByteReader::new(&mut fr);
481 let (name, score) = detect_format(name, &mut br).unwrap();
482 assert_eq!(name, "gdv");
483 assert_eq!(score, DetectionScore::MagicMatches);