mirror of
https://github.com/arsenetar/dupeguru.git
synced 2024-10-30 05:15:57 +00:00
336 lines
11 KiB
Python
336 lines
11 KiB
Python
# Created By: Virgil Dupras
|
|
# Created On: 2011-04-20
|
|
# Copyright 2013 Hardcoded Software (http://www.hardcoded.net)
|
|
#
|
|
# This software is licensed under the "BSD" License as described in the "LICENSE" file,
|
|
# which should be included with this package. The terms are also available at
|
|
# http://www.hardcoded.net/licenses/bsd_license
|
|
|
|
# Heavily based on http://topo.math.u-psud.fr/~bousch/exifdump.py by Thierry Bousch (Public Domain)
|
|
|
|
import logging
|
|
|
|
EXIF_TAGS = {
|
|
0x0100: "ImageWidth",
|
|
0x0101: "ImageLength",
|
|
0x0102: "BitsPerSample",
|
|
0x0103: "Compression",
|
|
0x0106: "PhotometricInterpretation",
|
|
0x010A: "FillOrder",
|
|
0x010D: "DocumentName",
|
|
0x010E: "ImageDescription",
|
|
0x010F: "Make",
|
|
0x0110: "Model",
|
|
0x0111: "StripOffsets",
|
|
0x0112: "Orientation",
|
|
0x0115: "SamplesPerPixel",
|
|
0x0116: "RowsPerStrip",
|
|
0x0117: "StripByteCounts",
|
|
0x011A: "XResolution",
|
|
0x011B: "YResolution",
|
|
0x011C: "PlanarConfiguration",
|
|
0x0128: "ResolutionUnit",
|
|
0x012D: "TransferFunction",
|
|
0x0131: "Software",
|
|
0x0132: "DateTime",
|
|
0x013B: "Artist",
|
|
0x013E: "WhitePoint",
|
|
0x013F: "PrimaryChromaticities",
|
|
0x0156: "TransferRange",
|
|
0x0200: "JPEGProc",
|
|
0x0201: "JPEGInterchangeFormat",
|
|
0x0202: "JPEGInterchangeFormatLength",
|
|
0x0211: "YCbCrCoefficients",
|
|
0x0212: "YCbCrSubSampling",
|
|
0x0213: "YCbCrPositioning",
|
|
0x0214: "ReferenceBlackWhite",
|
|
0x828F: "BatteryLevel",
|
|
0x8298: "Copyright",
|
|
0x829A: "ExposureTime",
|
|
0x829D: "FNumber",
|
|
0x83BB: "IPTC/NAA",
|
|
0x8769: "ExifIFDPointer",
|
|
0x8773: "InterColorProfile",
|
|
0x8822: "ExposureProgram",
|
|
0x8824: "SpectralSensitivity",
|
|
0x8825: "GPSInfoIFDPointer",
|
|
0x8827: "ISOSpeedRatings",
|
|
0x8828: "OECF",
|
|
0x9000: "ExifVersion",
|
|
0x9003: "DateTimeOriginal",
|
|
0x9004: "DateTimeDigitized",
|
|
0x9101: "ComponentsConfiguration",
|
|
0x9102: "CompressedBitsPerPixel",
|
|
0x9201: "ShutterSpeedValue",
|
|
0x9202: "ApertureValue",
|
|
0x9203: "BrightnessValue",
|
|
0x9204: "ExposureBiasValue",
|
|
0x9205: "MaxApertureValue",
|
|
0x9206: "SubjectDistance",
|
|
0x9207: "MeteringMode",
|
|
0x9208: "LightSource",
|
|
0x9209: "Flash",
|
|
0x920A: "FocalLength",
|
|
0x9214: "SubjectArea",
|
|
0x927C: "MakerNote",
|
|
0x9286: "UserComment",
|
|
0x9290: "SubSecTime",
|
|
0x9291: "SubSecTimeOriginal",
|
|
0x9292: "SubSecTimeDigitized",
|
|
0xA000: "FlashPixVersion",
|
|
0xA001: "ColorSpace",
|
|
0xA002: "PixelXDimension",
|
|
0xA003: "PixelYDimension",
|
|
0xA004: "RelatedSoundFile",
|
|
0xA005: "InteroperabilityIFDPointer",
|
|
0xA20B: "FlashEnergy", # 0x920B in TIFF/EP
|
|
0xA20C: "SpatialFrequencyResponse", # 0x920C - -
|
|
0xA20E: "FocalPlaneXResolution", # 0x920E - -
|
|
0xA20F: "FocalPlaneYResolution", # 0x920F - -
|
|
0xA210: "FocalPlaneResolutionUnit", # 0x9210 - -
|
|
0xA214: "SubjectLocation", # 0x9214 - -
|
|
0xA215: "ExposureIndex", # 0x9215 - -
|
|
0xA217: "SensingMethod", # 0x9217 - -
|
|
0xA300: "FileSource",
|
|
0xA301: "SceneType",
|
|
0xA302: "CFAPattern", # 0x828E in TIFF/EP
|
|
0xA401: "CustomRendered",
|
|
0xA402: "ExposureMode",
|
|
0xA403: "WhiteBalance",
|
|
0xA404: "DigitalZoomRatio",
|
|
0xA405: "FocalLengthIn35mmFilm",
|
|
0xA406: "SceneCaptureType",
|
|
0xA407: "GainControl",
|
|
0xA408: "Contrast",
|
|
0xA409: "Saturation",
|
|
0xA40A: "Sharpness",
|
|
0xA40B: "DeviceSettingDescription",
|
|
0xA40C: "SubjectDistanceRange",
|
|
0xA420: "ImageUniqueID",
|
|
}
|
|
|
|
INTR_TAGS = {
|
|
0x0001: "InteroperabilityIndex",
|
|
0x0002: "InteroperabilityVersion",
|
|
0x1000: "RelatedImageFileFormat",
|
|
0x1001: "RelatedImageWidth",
|
|
0x1002: "RelatedImageLength",
|
|
}
|
|
|
|
GPS_TA0GS = {
|
|
0x00: "GPSVersionID",
|
|
0x01: "GPSLatitudeRef",
|
|
0x02: "GPSLatitude",
|
|
0x03: "GPSLongitudeRef",
|
|
0x04: "GPSLongitude",
|
|
0x05: "GPSAltitudeRef",
|
|
0x06: "GPSAltitude",
|
|
0x07: "GPSTimeStamp",
|
|
0x08: "GPSSatellites",
|
|
0x09: "GPSStatus",
|
|
0x0A: "GPSMeasureMode",
|
|
0x0B: "GPSDOP",
|
|
0x0C: "GPSSpeedRef",
|
|
0x0D: "GPSSpeed",
|
|
0x0E: "GPSTrackRef",
|
|
0x0F: "GPSTrack",
|
|
0x10: "GPSImgDirectionRef",
|
|
0x11: "GPSImgDirection",
|
|
0x12: "GPSMapDatum",
|
|
0x13: "GPSDestLatitudeRef",
|
|
0x14: "GPSDestLatitude",
|
|
0x15: "GPSDestLongitudeRef",
|
|
0x16: "GPSDestLongitude",
|
|
0x17: "GPSDestBearingRef",
|
|
0x18: "GPSDestBearing",
|
|
0x19: "GPSDestDistanceRef",
|
|
0x1A: "GPSDestDistance",
|
|
0x1B: "GPSProcessingMethod",
|
|
0x1C: "GPSAreaInformation",
|
|
0x1D: "GPSDateStamp",
|
|
0x1E: "GPSDifferential"
|
|
}
|
|
|
|
INTEL_ENDIAN = ord('I')
|
|
MOTOROLA_ENDIAN = ord('M')
|
|
|
|
# About MAX_COUNT: It's possible to have corrupted exif tags where the entry count is way too high
|
|
# and thus makes us loop, not endlessly, but for heck of a long time for nothing. Therefore, we put
|
|
# an arbitrary limit on the entry count we'll allow ourselves to read and any IFD reporting more
|
|
# entries than that will be considered corrupt.
|
|
MAX_COUNT = 0xffff
|
|
|
|
def s2n_motorola(bytes):
|
|
x = 0
|
|
for c in bytes:
|
|
x = (x << 8) | c
|
|
return x
|
|
|
|
def s2n_intel(bytes):
|
|
x = 0
|
|
y = 0
|
|
for c in bytes:
|
|
x = x | (c << y)
|
|
y = y + 8
|
|
return x
|
|
|
|
class Fraction:
|
|
def __init__(self, num, den):
|
|
self.num = num
|
|
self.den = den
|
|
|
|
def __repr__(self):
|
|
return '%d/%d' % (self.num, self.den)
|
|
|
|
|
|
class TIFF_file:
|
|
def __init__(self, data):
|
|
self.data = data
|
|
self.endian = data[0]
|
|
self.s2nfunc = s2n_intel if self.endian == INTEL_ENDIAN else s2n_motorola
|
|
|
|
def s2n(self, offset, length, signed=0, debug=False):
|
|
slice = self.data[offset:offset+length]
|
|
val = self.s2nfunc(slice)
|
|
# Sign extension ?
|
|
if signed:
|
|
msb = 1 << (8*length - 1)
|
|
if val & msb:
|
|
val = val - (msb << 1)
|
|
if debug:
|
|
logging.debug(self.endian)
|
|
logging.debug("Slice for offset %d length %d: %r and value: %d", offset, length, slice, val)
|
|
return val
|
|
|
|
def first_IFD(self):
|
|
return self.s2n(4, 4)
|
|
|
|
def next_IFD(self, ifd):
|
|
entries = self.s2n(ifd, 2)
|
|
return self.s2n(ifd + 2 + 12 * entries, 4)
|
|
|
|
def list_IFDs(self):
|
|
i = self.first_IFD()
|
|
a = []
|
|
while i:
|
|
a.append(i)
|
|
i = self.next_IFD(i)
|
|
return a
|
|
|
|
def dump_IFD(self, ifd):
|
|
entries = self.s2n(ifd, 2)
|
|
logging.debug("Entries for IFD %d: %d", ifd, entries)
|
|
if entries > MAX_COUNT:
|
|
logging.debug("Probably corrupt. Aborting.")
|
|
return []
|
|
a = []
|
|
for i in range(entries):
|
|
entry = ifd + 2 + 12*i
|
|
tag = self.s2n(entry, 2)
|
|
type = self.s2n(entry+2, 2)
|
|
if not 1 <= type <= 10:
|
|
continue # not handled
|
|
typelen = [ 1, 1, 2, 4, 8, 1, 1, 2, 4, 8 ] [type-1]
|
|
count = self.s2n(entry+4, 4)
|
|
if count > MAX_COUNT:
|
|
logging.debug("Probably corrupt. Aborting.")
|
|
return []
|
|
offset = entry+8
|
|
if count*typelen > 4:
|
|
offset = self.s2n(offset, 4)
|
|
if type == 2:
|
|
# Special case: nul-terminated ASCII string
|
|
values = str(self.data[offset:offset+count-1], encoding='latin-1')
|
|
else:
|
|
values = []
|
|
signed = (type == 6 or type >= 8)
|
|
for j in range(count):
|
|
if type in {5, 10}:
|
|
# The type is either 5 or 10
|
|
value_j = Fraction(self.s2n(offset, 4, signed),
|
|
self.s2n(offset+4, 4, signed))
|
|
else:
|
|
# Not a fraction
|
|
value_j = self.s2n(offset, typelen, signed)
|
|
values.append(value_j)
|
|
offset = offset + typelen
|
|
# Now "values" is either a string or an array
|
|
a.append((tag,type,values))
|
|
return a
|
|
|
|
def read_exif_header(fp):
|
|
# If `fp`'s first bytes are not exif, it tries to find it in the next 4kb
|
|
def isexif(data):
|
|
return data[0:4] == b'\377\330\377\341' and data[6:10] == b'Exif'
|
|
data = fp.read(12)
|
|
if isexif(data):
|
|
return data
|
|
# ok, not exif, try to find it
|
|
large_data = fp.read(4096)
|
|
try:
|
|
index = large_data.index(b'Exif')
|
|
data = large_data[index-6:index+6]
|
|
# large_data omits the first 12 bytes, and the index is at the middle of the header, so we
|
|
# must seek index + 18
|
|
fp.seek(index+18)
|
|
return data
|
|
except ValueError:
|
|
raise ValueError("Not an Exif file")
|
|
|
|
def get_fields(fp):
|
|
data = read_exif_header(fp)
|
|
length = data[4] * 256 + data[5]
|
|
logging.debug("Exif header length: %d bytes", length)
|
|
data = fp.read(length-8)
|
|
data_format = data[0]
|
|
logging.debug("%s format", {INTEL_ENDIAN:'Intel', MOTOROLA_ENDIAN:'Motorola'}[data_format])
|
|
T = TIFF_file(data)
|
|
# There may be more than one IFD per file, but we only read the first one because others are
|
|
# most likely thumbnails.
|
|
main_IFD_offset = T.first_IFD()
|
|
result = {}
|
|
|
|
def add_tag_to_result(tag, values):
|
|
try:
|
|
stag = EXIF_TAGS[tag]
|
|
except KeyError:
|
|
stag = '0x%04X' % tag
|
|
if stag in result:
|
|
return # don't overwrite data
|
|
result[stag] = values
|
|
|
|
logging.debug("IFD at offset %d", main_IFD_offset)
|
|
IFD = T.dump_IFD(main_IFD_offset)
|
|
exif_off = gps_off = 0
|
|
for tag, type, values in IFD:
|
|
if tag == 0x8769:
|
|
exif_off = values[0]
|
|
continue
|
|
if tag == 0x8825:
|
|
gps_off = values[0]
|
|
continue
|
|
add_tag_to_result(tag, values)
|
|
if exif_off:
|
|
logging.debug("Exif SubIFD at offset %d:", exif_off)
|
|
IFD = T.dump_IFD(exif_off)
|
|
# Recent digital cameras have a little subdirectory
|
|
# here, pointed to by tag 0xA005. Apparently, it's the
|
|
# "Interoperability IFD", defined in Exif 2.1 and DCF.
|
|
intr_off = 0
|
|
for tag, type, values in IFD:
|
|
if tag == 0xA005:
|
|
intr_off = values[0]
|
|
continue
|
|
add_tag_to_result(tag, values)
|
|
if intr_off:
|
|
logging.debug("Exif Interoperability SubSubIFD at offset %d:", intr_off)
|
|
IFD = T.dump_IFD(intr_off)
|
|
for tag, type, values in IFD:
|
|
add_tag_to_result(tag, values)
|
|
if gps_off:
|
|
logging.debug("GPS SubIFD at offset %d:", gps_off)
|
|
IFD = T.dump_IFD(gps_off)
|
|
for tag, type, values in IFD:
|
|
add_tag_to_result(tag, values)
|
|
return result
|