2 use crate::io::byteio::ByteReader;
4 #[derive(Debug,Clone,Copy,PartialEq)]
5 pub enum DetectionScore {
12 pub fn less(&self, other: DetectionScore) -> bool {
13 (*self as i32) < (other as i32)
31 fn val(&self) -> u64 {
33 Arg::Byte(b) => { b as u64 }
34 Arg::U16BE(v) => { v as u64 }
35 Arg::U16LE(v) => { v as u64 }
36 Arg::U24BE(v) => { v as u64 }
37 Arg::U24LE(v) => { v as u64 }
38 Arg::U32BE(v) => { v as u64 }
39 Arg::U32LE(v) => { v as u64 }
40 Arg::U64BE(v) => { v }
41 Arg::U64LE(v) => { v }
44 fn read_val(&self, src: &mut ByteReader) -> Option<u64> {
47 let res = src.peek_byte();
48 if let Err(_) = res { return None; }
49 Some(res.unwrap() as u64)
52 let res = src.peek_u16be();
53 if let Err(_) = res { return None; }
54 Some(res.unwrap() as u64)
57 let res = src.peek_u16le();
58 if let Err(_) = res { return None; }
59 Some(res.unwrap() as u64)
62 let res = src.peek_u24be();
63 if let Err(_) = res { return None; }
64 Some(res.unwrap() as u64)
67 let res = src.peek_u24le();
68 if let Err(_) = res { return None; }
69 Some(res.unwrap() as u64)
72 let res = src.peek_u32be();
73 if let Err(_) = res { return None; }
74 Some(res.unwrap() as u64)
77 let res = src.peek_u32le();
78 if let Err(_) = res { return None; }
79 Some(res.unwrap() as u64)
82 let res = src.peek_u64be();
83 if let Err(_) = res { return None; }
87 let res = src.peek_u64le();
88 if let Err(_) = res { return None; }
93 fn eq(&self, src: &mut ByteReader) -> bool {
94 let val = self.read_val(src);
95 if let None = val { false }
96 else { val.unwrap() == self.val() }
98 fn ge(&self, src: &mut ByteReader) -> bool {
99 let val = self.read_val(src);
100 if let None = val { false }
101 else { val.unwrap() >= self.val() }
103 fn gt(&self, src: &mut ByteReader) -> bool {
104 let val = self.read_val(src);
105 if let None = val { false }
106 else { val.unwrap() > self.val() }
108 fn le(&self, src: &mut ByteReader) -> bool {
109 let val = self.read_val(src);
110 if let None = val { false }
111 else { val.unwrap() <= self.val() }
113 fn lt(&self, src: &mut ByteReader) -> bool {
114 let val = self.read_val(src);
115 if let None = val { false }
116 else { val.unwrap() < self.val() }
122 Or(&'a CC<'a>, &'a CC<'a>),
133 fn eval(&self, src: &mut ByteReader) -> bool {
135 CC::Or (ref a, ref b) => { a.eval(src) || b.eval(src) },
136 CC::Eq(ref arg) => { arg.eq(src) },
137 CC::In(ref a, ref b) => { a.le(src) && b.ge(src) },
138 CC::Lt(ref arg) => { arg.lt(src) },
139 CC::Le(ref arg) => { arg.le(src) },
140 CC::Gt(ref arg) => { arg.gt(src) },
141 CC::Ge(ref arg) => { arg.ge(src) },
143 let mut val: Vec<u8> = Vec::with_capacity(str.len());
144 val.resize(str.len(), 0);
145 let res = src.peek_buf(val.as_mut_slice());
146 if let Err(_) = res { return false; }
153 struct CheckItem<'a> {
159 struct DetectConditions<'a> {
160 demux_name: &'static str,
161 extensions: &'static str,
162 conditions: &'a [CheckItem<'a>],
165 const DETECTORS: &[DetectConditions] = &[
169 conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::Str(b"RIFF"), &CC::Str(b"ON2 ")) },
170 CheckItem{offs: 8, cond: &CC::Or(&CC::Or(&CC::Str(b"AVI LIST"),
171 &CC::Str(b"AVIXLIST")),
172 &CC::Str(b"ON2fLIST")) },
178 conditions: &[CheckItem{offs: 0, cond: &CC::Eq(Arg::U32LE(0x29111994))}],
181 demux_name: "realaudio",
182 extensions: ".ra,.ram",
183 conditions: &[CheckItem{offs: 0, cond: &CC::Str(b".ra\xFD")}],
186 demux_name: "realmedia",
187 extensions: ".rm,.rmvb,.rma,.ra,.ram",
188 conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::Str(b".RMF"), &CC::Str(b".RMP")) },
189 CheckItem{offs: 4, cond: &CC::Ge(Arg::U32BE(10))}],
192 demux_name: "real_ivr",
194 conditions: &[CheckItem{offs: 0, cond: &CC::Or(&CC::Str(b".R1M"), &CC::Str(b".REC"))}],
198 pub fn detect_format(name: &str, src: &mut ByteReader) -> Option<(&'static str, DetectionScore)> {
199 let mut result = None;
200 let lname = name.to_lowercase();
201 for detector in DETECTORS {
202 let mut score = DetectionScore::No;
204 for ext in detector.extensions.split(',') {
205 if lname.ends_with(ext) {
206 score = DetectionScore::ExtensionMatches;
211 let mut passed = detector.conditions.len() > 0;
212 for ck in detector.conditions {
213 let ret = src.seek(SeekFrom::Start(ck.offs as u64));
214 if let Err(_) = ret {
218 if !ck.cond.eval(src) {
224 score = DetectionScore::MagicMatches;
226 if score == DetectionScore::MagicMatches {
227 return Some((detector.demux_name, score));
229 if let None = result {
230 result = Some((detector.demux_name, score));
232 let (_, oldsc) = result.unwrap();
233 if oldsc.less(score) {
234 result = Some((detector.demux_name, score));
245 use crate::io::byteio::*;
248 fn test_avi_detect() {
249 let name = "assets/laser05.avi";
250 let mut file = File::open(name).unwrap();
251 let mut fr = FileReader::new_read(&mut file);
252 let mut br = ByteReader::new(&mut fr);
253 let (name, score) = detect_format(name, &mut br).unwrap();
254 assert_eq!(name, "avi");
255 assert_eq!(score, DetectionScore::MagicMatches);
259 fn test_gdv_detect() {
260 let name = "assets/intro1.gdv";
261 let mut file = File::open(name).unwrap();
262 let mut fr = FileReader::new_read(&mut file);
263 let mut br = ByteReader::new(&mut fr);
264 let (name, score) = detect_format(name, &mut br).unwrap();
265 assert_eq!(name, "gdv");
266 assert_eq!(score, DetectionScore::MagicMatches);