82d61d1f93
Animated GIFs are transcoded to AVC because it is much smaller and thus also suitable for long/large animations. In addition, this commit adds support for more metadata fields such as frame rate, number of frames, file capture timestamp (unix milliseconds), media type, and software version. Support for SVG files can later be implemented in a similar way.
325 lines
8.4 KiB
Go
325 lines
8.4 KiB
Go
package meta
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"path/filepath"
|
|
"runtime/debug"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/dsoprea/go-exif/v3"
|
|
"gopkg.in/photoprism/go-tz.v2/tz"
|
|
|
|
exifcommon "github.com/dsoprea/go-exif/v3/common"
|
|
|
|
"github.com/photoprism/photoprism/pkg/fs"
|
|
"github.com/photoprism/photoprism/pkg/rnd"
|
|
"github.com/photoprism/photoprism/pkg/sanitize"
|
|
"github.com/photoprism/photoprism/pkg/txt"
|
|
)
|
|
|
|
var exifIfdMapping *exifcommon.IfdMapping
|
|
var exifTagIndex = exif.NewTagIndex()
|
|
var exifMutex = sync.Mutex{}
|
|
var exifDateTimeTags = []string{"DateTimeOriginal", "DateTimeDigitized", "CreateDate", "DateTime"}
|
|
var exifSubSecTags = []string{"SubSecTimeOriginal", "SubSecTimeDigitized", "SubSecTime"}
|
|
|
|
func init() {
|
|
exifIfdMapping = exifcommon.NewIfdMapping()
|
|
|
|
if err := exifcommon.LoadStandardIfds(exifIfdMapping); err != nil {
|
|
log.Errorf("metadata: %s", err.Error())
|
|
}
|
|
}
|
|
|
|
// Exif parses an image file for Exif metadata and returns as Data struct.
|
|
func Exif(fileName string, fileType fs.Format, bruteForce bool) (data Data, err error) {
|
|
err = data.Exif(fileName, fileType, bruteForce)
|
|
|
|
return data, err
|
|
}
|
|
|
|
// Exif parses an image file for Exif metadata and returns as Data struct.
|
|
func (data *Data) Exif(fileName string, fileFormat fs.Format, bruteForce bool) (err error) {
|
|
exifMutex.Lock()
|
|
defer exifMutex.Unlock()
|
|
|
|
defer func() {
|
|
if e := recover(); e != nil {
|
|
err = fmt.Errorf("metadata: %s in %s (exif panic)\nstack: %s", e, sanitize.Log(filepath.Base(fileName)), debug.Stack())
|
|
}
|
|
}()
|
|
|
|
// Extract raw Exif block.
|
|
rawExif, err := RawExif(fileName, fileFormat, bruteForce)
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
logName := sanitize.Log(filepath.Base(fileName))
|
|
|
|
// Enumerate data.exif in Exif block.
|
|
opt := exif.ScanOptions{}
|
|
entries, _, err := exif.GetFlatExifData(rawExif, &opt)
|
|
|
|
// Create large enough map for values.
|
|
if data.exif == nil {
|
|
data.exif = make(map[string]string, len(entries))
|
|
}
|
|
|
|
// Ignore IFD1 data.exif with existing IFD0 values.
|
|
// see https://github.com/photoprism/photoprism/issues/2231
|
|
for _, tag := range entries {
|
|
s := strings.Split(tag.FormattedFirst, "\x00")[0]
|
|
if tag.TagName != "" && s != "" && (data.exif[tag.TagName] == "" || tag.IfdPath != exif.ThumbnailFqIfdPath) {
|
|
data.exif[tag.TagName] = s
|
|
}
|
|
}
|
|
|
|
// Abort if no values were found.
|
|
if len(data.exif) == 0 {
|
|
return fmt.Errorf("metadata: no exif data in %s", logName)
|
|
}
|
|
|
|
var ifdIndex exif.IfdIndex
|
|
_, ifdIndex, err = exif.Collect(exifIfdMapping, exifTagIndex, rawExif)
|
|
|
|
// Find and parse GPS coordinates.
|
|
if err != nil {
|
|
log.Debugf("metadata: %s in %s (exif)", err, logName)
|
|
} else {
|
|
var ifd *exif.Ifd
|
|
if ifd, err = ifdIndex.RootIfd.ChildWithIfdPath(exifcommon.IfdGpsInfoStandardIfdIdentity); err == nil {
|
|
var gi *exif.GpsInfo
|
|
if gi, err = ifd.GpsInfo(); err != nil {
|
|
log.Infof("metadata: %s in %s (exif)", err, logName)
|
|
} else {
|
|
if !math.IsNaN(gi.Latitude.Decimal()) && !math.IsNaN(gi.Longitude.Decimal()) {
|
|
data.Lat = float32(gi.Latitude.Decimal())
|
|
data.Lng = float32(gi.Longitude.Decimal())
|
|
} else if gi.Altitude != 0 || !gi.Timestamp.IsZero() {
|
|
log.Warnf("metadata: invalid exif gps coordinates in %s (%s)", logName, sanitize.Log(gi.String()))
|
|
}
|
|
|
|
if gi.Altitude != 0 {
|
|
data.Altitude = gi.Altitude
|
|
}
|
|
|
|
if !gi.Timestamp.IsZero() {
|
|
data.TakenGps = gi.Timestamp
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if value, ok := data.exif["Artist"]; ok {
|
|
data.Artist = SanitizeString(value)
|
|
}
|
|
|
|
if value, ok := data.exif["Copyright"]; ok {
|
|
data.Copyright = SanitizeString(value)
|
|
}
|
|
|
|
if value, ok := data.exif["Model"]; ok {
|
|
data.CameraModel = SanitizeString(value)
|
|
} else if value, ok := data.exif["CameraModel"]; ok {
|
|
data.CameraModel = SanitizeString(value)
|
|
}
|
|
|
|
if value, ok := data.exif["Make"]; ok {
|
|
data.CameraMake = SanitizeString(value)
|
|
} else if value, ok := data.exif["CameraMake"]; ok {
|
|
data.CameraMake = SanitizeString(value)
|
|
}
|
|
|
|
if value, ok := data.exif["CameraOwnerName"]; ok {
|
|
data.CameraOwner = SanitizeString(value)
|
|
}
|
|
|
|
if value, ok := data.exif["BodySerialNumber"]; ok {
|
|
data.CameraSerial = SanitizeString(value)
|
|
}
|
|
|
|
if value, ok := data.exif["LensMake"]; ok {
|
|
data.LensMake = SanitizeString(value)
|
|
}
|
|
|
|
if value, ok := data.exif["LensModel"]; ok {
|
|
data.LensModel = SanitizeString(value)
|
|
}
|
|
|
|
if value, ok := data.exif["Software"]; ok {
|
|
data.Software = SanitizeString(value)
|
|
}
|
|
|
|
if value, ok := data.exif["ExposureTime"]; ok {
|
|
if n := strings.Split(value, "/"); len(n) == 2 {
|
|
if n[0] != "1" && len(n[0]) < len(n[1]) {
|
|
n0, _ := strconv.ParseUint(n[0], 10, 64)
|
|
if n1, err := strconv.ParseUint(n[1], 10, 64); err == nil && n0 > 0 && n1 > 0 {
|
|
value = fmt.Sprintf("1/%d", n1/n0)
|
|
}
|
|
}
|
|
}
|
|
|
|
data.Exposure = value
|
|
}
|
|
|
|
if value, ok := data.exif["FNumber"]; ok {
|
|
values := strings.Split(value, "/")
|
|
|
|
if len(values) == 2 && values[1] != "0" && values[1] != "" {
|
|
number, _ := strconv.ParseFloat(values[0], 64)
|
|
denom, _ := strconv.ParseFloat(values[1], 64)
|
|
|
|
data.FNumber = float32(math.Round((number/denom)*1000) / 1000)
|
|
}
|
|
}
|
|
|
|
if value, ok := data.exif["ApertureValue"]; ok {
|
|
values := strings.Split(value, "/")
|
|
|
|
if len(values) == 2 && values[1] != "0" && values[1] != "" {
|
|
number, _ := strconv.ParseFloat(values[0], 64)
|
|
denom, _ := strconv.ParseFloat(values[1], 64)
|
|
|
|
data.Aperture = float32(math.Round((number/denom)*1000) / 1000)
|
|
}
|
|
}
|
|
|
|
if value, ok := data.exif["FocalLengthIn35mmFilm"]; ok {
|
|
if i, err := strconv.Atoi(value); err == nil {
|
|
data.FocalLength = i
|
|
}
|
|
} else if value, ok := data.exif["FocalLength"]; ok {
|
|
values := strings.Split(value, "/")
|
|
|
|
if len(values) == 2 && values[1] != "0" && values[1] != "" {
|
|
number, _ := strconv.ParseFloat(values[0], 64)
|
|
denom, _ := strconv.ParseFloat(values[1], 64)
|
|
|
|
data.FocalLength = int(math.Round((number/denom)*1000) / 1000)
|
|
}
|
|
}
|
|
|
|
if value, ok := data.exif["ISOSpeedRatings"]; ok {
|
|
if i, err := strconv.Atoi(value); err == nil {
|
|
data.Iso = i
|
|
}
|
|
}
|
|
|
|
if value, ok := data.exif["ImageUniqueID"]; ok {
|
|
if id := rnd.SanitizeUUID(value); id != "" {
|
|
data.DocumentID = id
|
|
}
|
|
}
|
|
|
|
if value, ok := data.exif["PixelXDimension"]; ok {
|
|
if i, err := strconv.Atoi(value); err == nil {
|
|
data.Width = i
|
|
}
|
|
} else if value, ok := data.exif["ImageWidth"]; ok {
|
|
if i, err := strconv.Atoi(value); err == nil {
|
|
data.Width = i
|
|
}
|
|
}
|
|
|
|
if value, ok := data.exif["PixelYDimension"]; ok {
|
|
if i, err := strconv.Atoi(value); err == nil {
|
|
data.Height = i
|
|
}
|
|
} else if value, ok := data.exif["ImageLength"]; ok {
|
|
if i, err := strconv.Atoi(value); err == nil {
|
|
data.Height = i
|
|
}
|
|
}
|
|
|
|
if value, ok := data.exif["Orientation"]; ok {
|
|
if i, err := strconv.Atoi(value); err == nil {
|
|
data.Orientation = i
|
|
}
|
|
} else {
|
|
data.Orientation = 1
|
|
}
|
|
|
|
if data.Lat != 0 && data.Lng != 0 {
|
|
zones, err := tz.GetZone(tz.Point{
|
|
Lat: float64(data.Lat),
|
|
Lon: float64(data.Lng),
|
|
})
|
|
|
|
if err == nil && len(zones) > 0 {
|
|
data.TimeZone = zones[0]
|
|
}
|
|
}
|
|
|
|
takenAt := time.Time{}
|
|
|
|
for _, name := range exifDateTimeTags {
|
|
if dateTime := txt.DateTime(data.exif[name], data.TimeZone); !dateTime.IsZero() {
|
|
takenAt = dateTime
|
|
break
|
|
}
|
|
}
|
|
|
|
// Fallback to GPS timestamp.
|
|
if takenAt.IsZero() && !data.TakenGps.IsZero() {
|
|
takenAt = data.TakenGps.UTC()
|
|
}
|
|
|
|
// Nanoseconds.
|
|
if data.TakenNs <= 0 {
|
|
for _, name := range exifSubSecTags {
|
|
if s := data.exif[name]; txt.IsPosInt(s) {
|
|
data.TakenNs = txt.Int(s + strings.Repeat("0", 9-len(s)))
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Valid time found in Exif metadata?
|
|
if !takenAt.IsZero() {
|
|
if takenAtLocal, err := time.ParseInLocation("2006-01-02T15:04:05", takenAt.Format("2006-01-02T15:04:05"), time.UTC); err == nil {
|
|
data.TakenAtLocal = takenAtLocal
|
|
} else {
|
|
data.TakenAtLocal = takenAt
|
|
}
|
|
|
|
data.TakenAt = takenAt.UTC()
|
|
}
|
|
|
|
// Add nanoseconds to the calculated UTC and local time.
|
|
if data.TakenAt.Nanosecond() == 0 {
|
|
if ns := time.Duration(data.TakenNs); ns > 0 && ns <= time.Second {
|
|
data.TakenAt.Truncate(time.Second).UTC().Add(ns)
|
|
data.TakenAtLocal.Truncate(time.Second).Add(ns)
|
|
}
|
|
}
|
|
|
|
if value, ok := data.exif["Flash"]; ok {
|
|
if i, err := strconv.Atoi(value); err == nil && i&1 == 1 {
|
|
data.AddKeywords(KeywordFlash)
|
|
data.Flash = true
|
|
}
|
|
}
|
|
|
|
if value, ok := data.exif["ImageDescription"]; ok {
|
|
data.AutoAddKeywords(value)
|
|
data.Description = SanitizeDescription(value)
|
|
}
|
|
|
|
if value, ok := data.exif["ProjectionType"]; ok {
|
|
data.AddKeywords(KeywordPanorama)
|
|
data.Projection = SanitizeString(value)
|
|
}
|
|
|
|
data.Subject = SanitizeMeta(data.Subject)
|
|
data.Artist = SanitizeMeta(data.Artist)
|
|
|
|
return nil
|
|
}
|