blob: cdbdad2ffd1c38484bc6d4000cde6f4d36f1e4a1 (
plain)
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
98
99
100
101
102
103
104
|
/* Copyright 2010-2015 Yorba Foundation
*
* This software is licensed under the GNU LGPL (version 2.1 or later).
* See the COPYING file in this distribution.
*/
public class DetectedPhotoInformation {
public PhotoFileFormat file_format = PhotoFileFormat.UNKNOWN;
public PhotoMetadata? metadata = null;
public string? md5 = null;
public string? exif_md5 = null;
public string? thumbnail_md5 = null;
public string? format_name = null;
public Dimensions image_dim = Dimensions();
public Gdk.Colorspace colorspace = Gdk.Colorspace.RGB;
public int channels = 0;
public int bits_per_channel = 0;
}
//
// A PhotoFileSniffer is expected to examine the supplied file as efficiently as humanly possible
// to detect (a) if it is of a file format supported by the particular sniffer, and (b) fill out
// a DetectedPhotoInformation record and return it to the caller.
//
// The PhotoFileSniffer is not expected to cache information. It should return a fresh
// DetectedPhotoInformation record each time.
//
// PhotoFileSniffer must be thread-safe. Like PhotoFileAdapters, it is not expected to guarantee
// atomicity with respect to the filesystem.
//
public abstract class PhotoFileSniffer {
public enum Options {
GET_ALL = 0x00000000,
NO_MD5 = 0x00000001
}
protected File file;
protected Options options;
protected bool calc_md5;
public PhotoFileSniffer(File file, Options options) {
this.file = file;
this.options = options;
calc_md5 = (options & Options.NO_MD5) == 0;
}
public abstract DetectedPhotoInformation? sniff(out bool is_corrupted) throws Error;
}
//
// PhotoFileInterrogator
//
// A PhotoFileInterrogator is merely an aggregator of PhotoFileSniffers. It will create sniffers
// for each supported PhotoFileFormat and see if they recognize the file.
//
// The PhotoFileInterrogator is not thread-safe.
//
public class PhotoFileInterrogator {
private File file;
private PhotoFileSniffer.Options options;
private DetectedPhotoInformation? detected = null;
private bool is_photo_corrupted = false;
public PhotoFileInterrogator(File file,
PhotoFileSniffer.Options options = PhotoFileSniffer.Options.GET_ALL) {
this.file = file;
this.options = options;
}
// This should only be called after interrogate(). Will return null every time, otherwise.
// If called after interrogate and returns null, that indicates the file is not an image file.
public DetectedPhotoInformation? get_detected_photo_information() {
return detected;
}
// Call after interrogate().
public bool get_is_photo_corrupted() {
return is_photo_corrupted;
}
public void interrogate() throws Error {
foreach (PhotoFileFormat file_format in PhotoFileFormat.get_supported()) {
PhotoFileSniffer sniffer = file_format.create_sniffer(file, options);
bool is_corrupted;
detected = sniffer.sniff(out is_corrupted);
if (detected != null && !is_corrupted) {
assert(detected.file_format == file_format);
break;
} else if (is_corrupted) {
message("Sniffing halted for %s: potentially corrupted image file", file.get_path());
is_photo_corrupted = true;
detected = null;
break;
}
}
}
}
|
