aicheck 0.2.0

Detect AI-generated content via provenance signals (C2PA, XMP/IPTC, EXIF)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use anyhow::Result;
use std::path::{Path, PathBuf};
use walkdir::WalkDir;

use crate::i18n;

/// Supported MIME types for analysis.
const SUPPORTED_TYPES: &[&str] = &[
    "image/jpeg",
    "image/png",
    "image/webp",
    "image/avif",
    "image/heif",
    "image/tiff",
    "image/gif",
    "image/bmp",
    "video/mp4",
    "video/quicktime",
    "video/x-msvideo",
    "video/webm",
    "audio/mpeg",
    "audio/mp4",
    "audio/wav",
    "audio/x-wav",
    "application/pdf",
];

fn is_supported(path: &Path) -> bool {
    // Try magic-byte detection first
    if let Ok(Some(kind)) = infer::get_from_path(path) {
        if SUPPORTED_TYPES.contains(&kind.mime_type()) {
            return true;
        }
    }
    // Fall back to extension for types infer might miss
    if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
        matches!(
            ext.to_lowercase().as_str(),
            "jpg"
                | "jpeg"
                | "png"
                | "webp"
                | "avif"
                | "heif"
                | "heic"
                | "tiff"
                | "tif"
                | "gif"
                | "bmp"
                | "mp4"
                | "mov"
                | "avi"
                | "webm"
                | "mp3"
                | "m4a"
                | "wav"
                | "pdf"
        )
    } else {
        false
    }
}

/// Discover files to analyze from the given paths.
pub fn discover_files(paths: &[PathBuf], recursive: bool) -> Result<Vec<PathBuf>> {
    let mut files = Vec::new();

    for path in paths {
        if path.is_file() {
            files.push(path.clone());
        } else if path.is_dir() {
            let walker = if recursive {
                WalkDir::new(path)
            } else {
                WalkDir::new(path).max_depth(1)
            };

            for entry in walker.into_iter().filter_map(|e| e.ok()) {
                let p = entry.path();
                if p.is_file() && is_supported(p) {
                    files.push(p.to_path_buf());
                }
            }
        } else {
            eprintln!(
                "{}",
                i18n::t(
                    "scanner_not_found",
                    &[("path", &path.display().to_string())]
                )
            );
        }
    }

    files.sort();
    Ok(files)
}