Debian Codegraph @

exif/exif.go

raw
1 // Package exif implements decoding of EXIF data as defined in the EXIF 2.2
2 // specification (http://www.exif.org/Exif2-2.PDF).
3 package exif
4
5 import (
6 "bufio"
7 "bytes"
8 "encoding/binary"
9 "encoding/json"
10 "errors"
11 "fmt"
12 "io"
13 "io/ioutil"
14 "math"
15 "strconv"
16 "strings"
17 "time"
18
19 "github.com/rwcarlsen/goexif/tiff"
20 )
21
22 const (
23 jpeg_APP1 = 0xE1
24
25 exifPointer = 0x8769
26 gpsPointer = 0x8825
27 interopPointer = 0xA005
28 )
29
30 // A decodeError is returned when the image cannot be decoded as a tiff image.
31 type decodeError struct {
32 cause error
33 }
34
35 func (de decodeError) Error() string {
36 return fmt.Sprintf("exif: decode failed (%v) ", de.cause.Error())
37 }
38
39 // IsShortReadTagValueError identifies a ErrShortReadTagValue error.
40 func IsShortReadTagValueError(err error) bool {
41 de, ok := err.(decodeError)
42 if ok {
43 return de.cause == tiff.ErrShortReadTagValue
44 }
45 return false
46 }
47
48 // A TagNotPresentError is returned when the requested field is not
49 // present in the EXIF.
50 type TagNotPresentError FieldName
51
52 func (tag TagNotPresentError) Error() string {
53 return fmt.Sprintf("exif: tag %q is not present", string(tag))
54 }
55
56 func IsTagNotPresentError(err error) bool {
57 _, ok := err.(TagNotPresentError)
58 return ok
59 }
60
61 // Parser allows the registration of custom parsing and field loading
62 // in the Decode function.
63 type Parser interface {
64 // Parse should read data from x and insert parsed fields into x via
65 // LoadTags.
66 Parse(x *Exif) error
67 }
68
69 var parsers []Parser
70
71 func init() {
72 RegisterParsers(&parser{})
73 }
74
75 // RegisterParsers registers one or more parsers to be automatically called
76 // when decoding EXIF data via the Decode function.
77 func RegisterParsers(ps ...Parser) {
78 parsers = append(parsers, ps...)
79 }
80
81 type parser struct{}
82
83 type tiffErrors map[tiffError]string
84
85 func (te tiffErrors) Error() string {
86 var allErrors []string
87 for k, v := range te {
88 allErrors = append(allErrors, fmt.Sprintf("%s: %v\n", stagePrefix[k], v))
89 }
90 return strings.Join(allErrors, "\n")
91 }
92
93 // IsCriticalError, given the error returned by Decode, reports whether the
94 // returned *Exif may contain usable information.
95 func IsCriticalError(err error) bool {
96 _, ok := err.(tiffErrors)
97 return !ok
98 }
99
100 // IsExifError reports whether the error happened while decoding the EXIF
101 // sub-IFD.
102 func IsExifError(err error) bool {
103 if te, ok := err.(tiffErrors); ok {
104 _, isExif := te[loadExif]
105 return isExif
106 }
107 return false
108 }
109
110 // IsGPSError reports whether the error happened while decoding the GPS sub-IFD.
111 func IsGPSError(err error) bool {
112 if te, ok := err.(tiffErrors); ok {
113 _, isGPS := te[loadExif]
114 return isGPS
115 }
116 return false
117 }
118
119 // IsInteroperabilityError reports whether the error happened while decoding the
120 // Interoperability sub-IFD.
121 func IsInteroperabilityError(err error) bool {
122 if te, ok := err.(tiffErrors); ok {
123 _, isInterop := te[loadInteroperability]
124 return isInterop
125 }
126 return false
127 }
128
129 type tiffError int
130
131 const (
132 loadExif tiffError = iota
133 loadGPS
134 loadInteroperability
135 )
136
137 var stagePrefix = map[tiffError]string{
138 loadExif: "loading EXIF sub-IFD",
139 loadGPS: "loading GPS sub-IFD",
140 loadInteroperability: "loading Interoperability sub-IFD",
141 }
142
143 // Parse reads data from the tiff data in x and populates the tags
144 // in x. If parsing a sub-IFD fails, the error is recorded and
145 // parsing continues with the remaining sub-IFDs.
146 func (p *parser) Parse(x *Exif) error {
147 if len(x.Tiff.Dirs) == 0 {
148 return errors.New("Invalid exif data")
149 }
150 x.LoadTags(x.Tiff.Dirs[0], exifFields, false)
151
152 // thumbnails
153 if len(x.Tiff.Dirs) >= 2 {
154 x.LoadTags(x.Tiff.Dirs[1], thumbnailFields, false)
155 }
156
157 te := make(tiffErrors)
158
159 // recurse into exif, gps, and interop sub-IFDs
160 if err := loadSubDir(x, ExifIFDPointer, exifFields); err != nil {
161 te[loadExif] = err.Error()
162 }
163 if err := loadSubDir(x, GPSInfoIFDPointer, gpsFields); err != nil {
164 te[loadGPS] = err.Error()
165 }
166
167 if err := loadSubDir(x, InteroperabilityIFDPointer, interopFields); err != nil {
168 te[loadInteroperability] = err.Error()
169 }
170 if len(te) > 0 {
171 return te
172 }
173 return nil
174 }
175
176 func loadSubDir(x *Exif, ptr FieldName, fieldMap map[uint16]FieldName) error {
177 r := bytes.NewReader(x.Raw)
178
179 tag, err := x.Get(ptr)
180 if err != nil {
181 return nil
182 }
183 offset, err := tag.Int64(0)
184 if err != nil {
185 return nil
186 }
187
188 _, err = r.Seek(offset, 0)
189 if err != nil {
190 return fmt.Errorf("exif: seek to sub-IFD %s failed: %v", ptr, err)
191 }
192 subDir, _, err := tiff.DecodeDir(r, x.Tiff.Order)
193 if err != nil {
194 return fmt.Errorf("exif: sub-IFD %s decode failed: %v", ptr, err)
195 }
196 x.LoadTags(subDir, fieldMap, false)
197 return nil
198 }
199
200 // Exif provides access to decoded EXIF metadata fields and values.
201 type Exif struct {
202 Tiff *tiff.Tiff
203 main map[FieldName]*tiff.Tag
204 Raw []byte
205 }
206
207 // Decode parses EXIF data from r (a TIFF, JPEG, or raw EXIF block)
208 // and returns a queryable Exif object. After the EXIF data section is
209 // called and the TIFF structure is decoded, each registered parser is
210 // called (in order of registration). If one parser returns an error,
211 // decoding terminates and the remaining parsers are not called.
212 //
213 // The error can be inspected with functions such as IsCriticalError
214 // to determine whether the returned object might still be usable.
215 func Decode(r io.Reader) (*Exif, error) {
216
217 // EXIF data in JPEG is stored in the APP1 marker. EXIF data uses the TIFF
218 // format to store data.
219 // If we're parsing a TIFF image, we don't need to strip away any data.
220 // If we're parsing a JPEG image, we need to strip away the JPEG APP1
221 // marker and also the EXIF header.
222
223 header := make([]byte, 4)
224 n, err := io.ReadFull(r, header)
225 if err != nil {
226 return nil, fmt.Errorf("exif: error reading 4 byte header, got %d, %v", n, err)
227 }
228
229 var isTiff bool
230 var isRawExif bool
231 var assumeJPEG bool
232 switch string(header) {
233 case "II*\x00":
234 // TIFF - Little endian (Intel)
235 isTiff = true
236 case "MM\x00*":
237 // TIFF - Big endian (Motorola)
238 isTiff = true
239 case "Exif":
240 isRawExif = true
241 default:
242 // Not TIFF, assume JPEG
243 assumeJPEG = true
244 }
245
246 // Put the header bytes back into the reader.
247 r = io.MultiReader(bytes.NewReader(header), r)
248 var (
249 er *bytes.Reader
250 tif *tiff.Tiff
251 sec *appSec
252 )
253
254 switch {
255 case isRawExif:
256 var header [6]byte
257 if _, err := io.ReadFull(r, header[:]); err != nil {
258 return nil, fmt.Errorf("exif: unexpected raw exif header read error")
259 }
260 if got, want := string(header[:]), "Exif\x00\x00"; got != want {
261 return nil, fmt.Errorf("exif: unexpected raw exif header; got %q, want %q", got, want)
262 }
263 fallthrough
264 case isTiff:
265 // Functions below need the IFDs from the TIFF data to be stored in a
266 // *bytes.Reader. We use TeeReader to get a copy of the bytes as a
267 // side-effect of tiff.Decode() doing its work.
268 b := &bytes.Buffer{}
269 tr := io.TeeReader(r, b)
270 tif, err = tiff.Decode(tr)
271 er = bytes.NewReader(b.Bytes())
272 case assumeJPEG:
273 // Locate the JPEG APP1 header.
274 sec, err = newAppSec(jpeg_APP1, r)
275 if err != nil {
276 return nil, err
277 }
278 // Strip away EXIF header.
279 er, err = sec.exifReader()
280 if err != nil {
281 return nil, err
282 }
283 tif, err = tiff.Decode(er)
284 }
285
286 if err != nil {
287 return nil, decodeError{cause: err}
288 }
289
290 er.Seek(0, 0)
291 raw, err := ioutil.ReadAll(er)
292 if err != nil {
293 return nil, decodeError{cause: err}
294 }
295
296 // build an exif structure from the tiff
297 x := &Exif{
298 main: map[FieldName]*tiff.Tag{},
299 Tiff: tif,
300 Raw: raw,
301 }
302
303 for i, p := range parsers {
304 if err := p.Parse(x); err != nil {
305 if _, ok := err.(tiffErrors); ok {
306 return x, err
307 }
308 // This should never happen, as Parse always returns a tiffError
309 // for now, but that could change.
310 return x, fmt.Errorf("exif: parser %v failed (%v)", i, err)
311 }
312 }
313
314 return x, nil
315 }
316
317 // LoadTags loads tags into the available fields from the tiff Directory
318 // using the given tagid-fieldname mapping. Used to load makernote and
319 // other meta-data. If showMissing is true, tags in d that are not in the
320 // fieldMap will be loaded with the FieldName UnknownPrefix followed by the
321 // tag ID (in hex format).
322 func (x *Exif) LoadTags(d *tiff.Dir, fieldMap map[uint16]FieldName, showMissing bool) {
323 for _, tag := range d.Tags {
324 name := fieldMap[tag.Id]
325 if name == "" {
326 if !showMissing {
327 continue
328 }
329 name = FieldName(fmt.Sprintf("%v%x", UnknownPrefix, tag.Id))
330 }
331 x.main[name] = tag
332 }
333 }
334
335 // Get retrieves the EXIF tag for the given field name.
336 //
337 // If the tag is not known or not present, an error is returned. If the
338 // tag name is known, the error will be a TagNotPresentError.
339 func (x *Exif) Get(name FieldName) (*tiff.Tag, error) {
340 if tg, ok := x.main[name]; ok {
341 return tg, nil
342 }
343 return nil, TagNotPresentError(name)
344 }
345
346 // Walker is the interface used to traverse all fields of an Exif object.
347 type Walker interface {
348 // Walk is called for each non-nil EXIF field. Returning a non-nil
349 // error aborts the walk/traversal.
350 Walk(name FieldName, tag *tiff.Tag) error
351 }
352
353 // Walk calls the Walk method of w with the name and tag for every non-nil
354 // EXIF field. If w aborts the walk with an error, that error is returned.
355 func (x *Exif) Walk(w Walker) error {
356 for name, tag := range x.main {
357 if err := w.Walk(name, tag); err != nil {
358 return err
359 }
360 }
361 return nil
362 }
363
364 // DateTime returns the EXIF's "DateTimeOriginal" field, which
365 // is the creation time of the photo. If not found, it tries
366 // the "DateTime" (which is meant as the modtime) instead.
367 // The error will be TagNotPresentErr if none of those tags
368 // were found, or a generic error if the tag value was
369 // not a string, or the error returned by time.Parse.
370 //
371 // If the EXIF lacks timezone information or GPS time, the returned
372 // time's Location will be time.Local.
373 func (x *Exif) DateTime() (time.Time, error) {
374 var dt time.Time
375 tag, err := x.Get(DateTimeOriginal)
376 if err != nil {
377 tag, err = x.Get(DateTime)
378 if err != nil {
379 return dt, err
380 }
381 }
382 if tag.Format() != tiff.StringVal {
383 return dt, errors.New("DateTime[Original] not in string format")
384 }
385 exifTimeLayout := "2006:01:02 15:04:05"
386 dateStr := strings.TrimRight(string(tag.Val), "\x00")
387 // TODO(bradfitz,mpl): look for timezone offset, GPS time, etc.
388 timeZone := time.Local
389 if tz, _ := x.TimeZone(); tz != nil {
390 timeZone = tz
391 }
392 return time.ParseInLocation(exifTimeLayout, dateStr, timeZone)
393 }
394
395 func (x *Exif) TimeZone() (*time.Location, error) {
396 // TODO: parse more timezone fields (e.g. Nikon WorldTime).
397 timeInfo, err := x.Get("Canon.TimeInfo")
398 if err != nil {
399 return nil, err
400 }
401 if timeInfo.Count < 2 {
402 return nil, errors.New("Canon.TimeInfo does not contain timezone")
403 }
404 offsetMinutes, err := timeInfo.Int(1)
405 if err != nil {
406 return nil, err
407 }
408 return time.FixedZone("", offsetMinutes*60), nil
409 }
410
411 func ratFloat(num, dem int64) float64 {
412 return float64(num) / float64(dem)
413 }
414
415 // Tries to parse a Geo degrees value from a string as it was found in some
416 // EXIF data.
417 // Supported formats so far:
418 // - "52,00000,50,00000,34,01180" ==> 52 deg 50'34.0118"
419 // Probably due to locale the comma is used as decimal mark as well as the
420 // separator of three floats (degrees, minutes, seconds)
421 // http://en.wikipedia.org/wiki/Decimal_mark#Hindu.E2.80.93Arabic_numeral_system
422 // - "52.0,50.0,34.01180" ==> 52deg50'34.0118"
423 // - "52,50,34.01180" ==> 52deg50'34.0118"
424 func parseTagDegreesString(s string) (float64, error) {
425 const unparsableErrorFmt = "Unknown coordinate format: %s"
426 isSplitRune := func(c rune) bool {
427 return c == ',' || c == ';'
428 }
429 parts := strings.FieldsFunc(s, isSplitRune)
430 var degrees, minutes, seconds float64
431 var err error
432 switch len(parts) {
433 case 6:
434 degrees, err = strconv.ParseFloat(parts[0]+"."+parts[1], 64)
435 if err != nil {
436 return 0.0, fmt.Errorf(unparsableErrorFmt, s)
437 }
438 minutes, err = strconv.ParseFloat(parts[2]+"."+parts[3], 64)
439 if err != nil {
440 return 0.0, fmt.Errorf(unparsableErrorFmt, s)
441 }
442 minutes = math.Copysign(minutes, degrees)
443 seconds, err = strconv.ParseFloat(parts[4]+"."+parts[5], 64)
444 if err != nil {
445 return 0.0, fmt.Errorf(unparsableErrorFmt, s)
446 }
447 seconds = math.Copysign(seconds, degrees)
448 case 3:
449 degrees, err = strconv.ParseFloat(parts[0], 64)
450 if err != nil {
451 return 0.0, fmt.Errorf(unparsableErrorFmt, s)
452 }
453 minutes, err = strconv.ParseFloat(parts[1], 64)
454 if err != nil {
455 return 0.0, fmt.Errorf(unparsableErrorFmt, s)
456 }
457 minutes = math.Copysign(minutes, degrees)
458 seconds, err = strconv.ParseFloat(parts[2], 64)
459 if err != nil {
460 return 0.0, fmt.Errorf(unparsableErrorFmt, s)
461 }
462 seconds = math.Copysign(seconds, degrees)
463 default:
464 return 0.0, fmt.Errorf(unparsableErrorFmt, s)
465 }
466 return degrees + minutes/60.0 + seconds/3600.0, nil
467 }
468
469 func parse3Rat2(tag *tiff.Tag) ([3]float64, error) {
470 v := [3]float64{}
471 for i := range v {
472 num, den, err := tag.Rat2(i)
473 if err != nil {
474 return v, err
475 }
476 v[i] = ratFloat(num, den)
477 if tag.Count < uint32(i+2) {
478 break
479 }
480 }
481 return v, nil
482 }
483
484 func tagDegrees(tag *tiff.Tag) (float64, error) {
485 switch tag.Format() {
486 case tiff.RatVal:
487 // The usual case, according to the Exif spec
488 // (http://www.kodak.com/global/plugins/acrobat/en/service/digCam/exifStandard2.pdf,
489 // sec 4.6.6, p. 52 et seq.)
490 v, err := parse3Rat2(tag)
491 if err != nil {
492 return 0.0, err
493 }
494 return v[0] + v[1]/60 + v[2]/3600.0, nil
495 case tiff.StringVal:
496 // Encountered this weird case with a panorama picture taken with a HTC phone
497 s, err := tag.StringVal()
498 if err != nil {
499 return 0.0, err
500 }
501 return parseTagDegreesString(s)
502 default:
503 // don't know how to parse value, give up
504 return 0.0, fmt.Errorf("Malformed EXIF Tag Degrees")
505 }
506 }
507
508 // LatLong returns the latitude and longitude of the photo and
509 // whether it was present.
510 func (x *Exif) LatLong() (lat, long float64, err error) {
511 // All calls of x.Get might return an TagNotPresentError
512 longTag, err := x.Get(FieldName("GPSLongitude"))
513 if err != nil {
514 return
515 }
516 ewTag, err := x.Get(FieldName("GPSLongitudeRef"))
517 if err != nil {
518 return
519 }
520 latTag, err := x.Get(FieldName("GPSLatitude"))
521 if err != nil {
522 return
523 }
524 nsTag, err := x.Get(FieldName("GPSLatitudeRef"))
525 if err != nil {
526 return
527 }
528 if long, err = tagDegrees(longTag); err != nil {
529 return 0, 0, fmt.Errorf("Cannot parse longitude: %v", err)
530 }
531 if lat, err = tagDegrees(latTag); err != nil {
532 return 0, 0, fmt.Errorf("Cannot parse latitude: %v", err)
533 }
534 ew, err := ewTag.StringVal()
535 if err == nil && ew == "W" {
536 long *= -1.0
537 } else if err != nil {
538 return 0, 0, fmt.Errorf("Cannot parse longitude: %v", err)
539 }
540 ns, err := nsTag.StringVal()
541 if err == nil && ns == "S" {
542 lat *= -1.0
543 } else if err != nil {
544 return 0, 0, fmt.Errorf("Cannot parse longitude: %v", err)
545 }
546 return lat, long, nil
547 }
548
549 // String returns a pretty text representation of the decoded exif data.
550 func (x *Exif) String() string {
551 var buf bytes.Buffer
552 for name, tag := range x.main {
553 fmt.Fprintf(&buf, "%s: %s\n", name, tag)
554 }
555 return buf.String()
556 }
557
558 // JpegThumbnail returns the jpeg thumbnail if it exists. If it doesn't exist,
559 // TagNotPresentError will be returned
560 func (x *Exif) JpegThumbnail() ([]byte, error) {
561 offset, err := x.Get(ThumbJPEGInterchangeFormat)
562 if err != nil {
563 return nil, err
564 }
565 start, err := offset.Int(0)
566 if err != nil {
567 return nil, err
568 }
569
570 length, err := x.Get(ThumbJPEGInterchangeFormatLength)
571 if err != nil {
572 return nil, err
573 }
574 l, err := length.Int(0)
575 if err != nil {
576 return nil, err
577 }
578
579 return x.Raw[start : start+l], nil
580 }
581
582 // MarshalJson implements the encoding/json.Marshaler interface providing output of
583 // all EXIF fields present (names and values).
584 func (x Exif) MarshalJSON() ([]byte, error) {
585 return json.Marshal(x.main)
586 }
587
588 type appSec struct {
589 marker byte
590 data []byte
591 }
592
593 // newAppSec finds marker in r and returns the corresponding application data
594 // section.
595 func newAppSec(marker byte, r io.Reader) (*appSec, error) {
596 br := bufio.NewReader(r)
597 app := &appSec{marker: marker}
598 var dataLen int
599
600 // seek to marker
601 for dataLen == 0 {
602 if _, err := br.ReadBytes(0xFF); err != nil {
603 return nil, err
604 }
605 c, err := br.ReadByte()
606 if err != nil {
607 return nil, err
608 } else if c != marker {
609 continue
610 }
611
612 dataLenBytes := make([]byte, 2)
613 for k, _ := range dataLenBytes {
614 c, err := br.ReadByte()
615 if err != nil {
616 return nil, err
617 }
618 dataLenBytes[k] = c
619 }
620 dataLen = int(binary.BigEndian.Uint16(dataLenBytes)) - 2
621 }
622
623 // read section data
624 nread := 0
625 for nread < dataLen {
626 s := make([]byte, dataLen-nread)
627 n, err := br.Read(s)
628 nread += n
629 if err != nil && nread < dataLen {
630 return nil, err
631 }
632 app.data = append(app.data, s[:n]...)
633 }
634 return app, nil
635 }
636
637 // reader returns a reader on this appSec.
638 func (app *appSec) reader() *bytes.Reader {
639 return bytes.NewReader(app.data)
640 }
641
642 // exifReader returns a reader on this appSec with the read cursor advanced to
643 // the start of the exif's tiff encoded portion.
644 func (app *appSec) exifReader() (*bytes.Reader, error) {
645 if len(app.data) < 6 {
646 return nil, errors.New("exif: failed to find exif intro marker")
647 }
648
649 // read/check for exif special mark
650 exif := app.data[:6]
651 if !bytes.Equal(exif, append([]byte("Exif"), 0x00, 0x00)) {
652 return nil, errors.New("exif: failed to find exif intro marker")
653 }
654 return bytes.NewReader(app.data[6:]), nil
655 }