summaryrefslogtreecommitdiff
path: root/vendor/github.com/dsoprea/go-exif/v3/ifd_enumerate.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/dsoprea/go-exif/v3/ifd_enumerate.go')
-rw-r--r--vendor/github.com/dsoprea/go-exif/v3/ifd_enumerate.go1672
1 files changed, 1672 insertions, 0 deletions
diff --git a/vendor/github.com/dsoprea/go-exif/v3/ifd_enumerate.go b/vendor/github.com/dsoprea/go-exif/v3/ifd_enumerate.go
new file mode 100644
index 000000000..3167596ef
--- /dev/null
+++ b/vendor/github.com/dsoprea/go-exif/v3/ifd_enumerate.go
@@ -0,0 +1,1672 @@
+package exif
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "io"
+ "strconv"
+ "strings"
+ "time"
+
+ "encoding/binary"
+
+ "github.com/dsoprea/go-logging"
+
+ "github.com/dsoprea/go-exif/v3/common"
+ "github.com/dsoprea/go-exif/v3/undefined"
+)
+
+var (
+ ifdEnumerateLogger = log.NewLogger("exif.ifd_enumerate")
+)
+
+var (
+ // ErrNoThumbnail means that no thumbnail was found.
+ ErrNoThumbnail = errors.New("no thumbnail")
+
+ // ErrNoGpsTags means that no GPS info was found.
+ ErrNoGpsTags = errors.New("no gps tags")
+
+ // ErrTagTypeNotValid means that the tag-type is not valid.
+ ErrTagTypeNotValid = errors.New("tag type invalid")
+
+ // ErrOffsetInvalid means that the file offset is not valid.
+ ErrOffsetInvalid = errors.New("file offset invalid")
+)
+
+var (
+ // ValidGpsVersions is the list of recognized EXIF GPS versions/signatures.
+ ValidGpsVersions = [][4]byte{
+ // 2.0.0.0 appears to have a very similar format to 2.2.0.0, so enabling
+ // it under that assumption.
+ //
+ // IFD-PATH=[IFD] ID=(0x8825) NAME=[GPSTag] COUNT=(1) TYPE=[LONG] VALUE=[114]
+ // IFD-PATH=[IFD/GPSInfo] ID=(0x0000) NAME=[GPSVersionID] COUNT=(4) TYPE=[BYTE] VALUE=[02 00 00 00]
+ // IFD-PATH=[IFD/GPSInfo] ID=(0x0001) NAME=[GPSLatitudeRef] COUNT=(2) TYPE=[ASCII] VALUE=[S]
+ // IFD-PATH=[IFD/GPSInfo] ID=(0x0002) NAME=[GPSLatitude] COUNT=(3) TYPE=[RATIONAL] VALUE=[38/1...]
+ // IFD-PATH=[IFD/GPSInfo] ID=(0x0003) NAME=[GPSLongitudeRef] COUNT=(2) TYPE=[ASCII] VALUE=[E]
+ // IFD-PATH=[IFD/GPSInfo] ID=(0x0004) NAME=[GPSLongitude] COUNT=(3) TYPE=[RATIONAL] VALUE=[144/1...]
+ // IFD-PATH=[IFD/GPSInfo] ID=(0x0012) NAME=[GPSMapDatum] COUNT=(7) TYPE=[ASCII] VALUE=[WGS-84]
+ //
+ {2, 0, 0, 0},
+
+ {2, 2, 0, 0},
+
+ // Suddenly appeared at the default in 2.31: https://home.jeita.or.jp/tsc/std-pdf/CP-3451D.pdf
+ //
+ // Note that the presence of 2.3.0.0 doesn't seem to guarantee
+ // coordinates. In some cases, we seen just the following:
+ //
+ // GPS Tag Version |2.3.0.0
+ // GPS Receiver Status |V
+ // Geodetic Survey Data|WGS-84
+ // GPS Differential Cor|0
+ //
+ {2, 3, 0, 0},
+ }
+)
+
+// byteParser knows how to decode an IFD and all of the tags it
+// describes.
+//
+// The IFDs and the actual values can float throughout the EXIF block, but the
+// IFD itself is just a minor header followed by a set of repeating,
+// statically-sized records. So, the tags (though notnecessarily their values)
+// are fairly simple to enumerate.
+type byteParser struct {
+ byteOrder binary.ByteOrder
+ rs io.ReadSeeker
+ ifdOffset uint32
+ currentOffset uint32
+}
+
+// newByteParser returns a new byteParser struct.
+//
+// initialOffset is for arithmetic-based tracking of where we should be at in
+// the stream.
+func newByteParser(rs io.ReadSeeker, byteOrder binary.ByteOrder, initialOffset uint32) (bp *byteParser, err error) {
+ // TODO(dustin): Add test
+
+ bp = &byteParser{
+ rs: rs,
+ byteOrder: byteOrder,
+ currentOffset: initialOffset,
+ }
+
+ return bp, nil
+}
+
+// getUint16 reads a uint16 and advances both our current and our current
+// accumulator (which allows us to know how far to seek to the beginning of the
+// next IFD when it's time to jump).
+func (bp *byteParser) getUint16() (value uint16, raw []byte, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ // TODO(dustin): Add test
+
+ needBytes := 2
+
+ raw = make([]byte, needBytes)
+
+ _, err = io.ReadFull(bp.rs, raw)
+ log.PanicIf(err)
+
+ value = bp.byteOrder.Uint16(raw)
+
+ bp.currentOffset += uint32(needBytes)
+
+ return value, raw, nil
+}
+
+// getUint32 reads a uint32 and advances both our current and our current
+// accumulator (which allows us to know how far to seek to the beginning of the
+// next IFD when it's time to jump).
+func (bp *byteParser) getUint32() (value uint32, raw []byte, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ // TODO(dustin): Add test
+
+ needBytes := 4
+
+ raw = make([]byte, needBytes)
+
+ _, err = io.ReadFull(bp.rs, raw)
+ log.PanicIf(err)
+
+ value = bp.byteOrder.Uint32(raw)
+
+ bp.currentOffset += uint32(needBytes)
+
+ return value, raw, nil
+}
+
+// CurrentOffset returns the starting offset but the number of bytes that we
+// have parsed. This is arithmetic-based tracking, not a seek(0) operation.
+func (bp *byteParser) CurrentOffset() uint32 {
+ return bp.currentOffset
+}
+
+// IfdEnumerate is the main enumeration type. It knows how to parse the IFD
+// containers in the EXIF blob.
+type IfdEnumerate struct {
+ ebs ExifBlobSeeker
+ byteOrder binary.ByteOrder
+ tagIndex *TagIndex
+ ifdMapping *exifcommon.IfdMapping
+ furthestOffset uint32
+
+ visitedIfdOffsets map[uint32]struct{}
+}
+
+// NewIfdEnumerate returns a new instance of IfdEnumerate.
+func NewIfdEnumerate(ifdMapping *exifcommon.IfdMapping, tagIndex *TagIndex, ebs ExifBlobSeeker, byteOrder binary.ByteOrder) *IfdEnumerate {
+ return &IfdEnumerate{
+ ebs: ebs,
+ byteOrder: byteOrder,
+ ifdMapping: ifdMapping,
+ tagIndex: tagIndex,
+
+ visitedIfdOffsets: make(map[uint32]struct{}),
+ }
+}
+
+func (ie *IfdEnumerate) getByteParser(ifdOffset uint32) (bp *byteParser, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ initialOffset := ExifAddressableAreaStart + ifdOffset
+
+ rs, err := ie.ebs.GetReadSeeker(int64(initialOffset))
+ log.PanicIf(err)
+
+ bp, err =
+ newByteParser(
+ rs,
+ ie.byteOrder,
+ initialOffset)
+
+ if err != nil {
+ if err == ErrOffsetInvalid {
+ return nil, err
+ }
+
+ log.Panic(err)
+ }
+
+ return bp, nil
+}
+
+func (ie *IfdEnumerate) parseTag(ii *exifcommon.IfdIdentity, tagPosition int, bp *byteParser) (ite *IfdTagEntry, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ tagId, _, err := bp.getUint16()
+ log.PanicIf(err)
+
+ tagTypeRaw, _, err := bp.getUint16()
+ log.PanicIf(err)
+
+ tagType := exifcommon.TagTypePrimitive(tagTypeRaw)
+
+ unitCount, _, err := bp.getUint32()
+ log.PanicIf(err)
+
+ valueOffset, rawValueOffset, err := bp.getUint32()
+ log.PanicIf(err)
+
+ // Check whether the embedded type indicator is valid.
+
+ if tagType.IsValid() == false {
+ // Technically, we have the type on-file in the tags-index, but
+ // if the type stored alongside the data disagrees with it,
+ // which it apparently does, all bets are off.
+ ifdEnumerateLogger.Warningf(nil,
+ "Tag (0x%04x) in IFD [%s] at position (%d) has invalid type (0x%04x) and will be skipped.",
+ tagId, ii, tagPosition, int(tagType))
+
+ ite = &IfdTagEntry{
+ tagId: tagId,
+ tagType: tagType,
+ }
+
+ return ite, ErrTagTypeNotValid
+ }
+
+ // Check whether the embedded type is listed among the supported types for
+ // the registered tag. If not, skip processing the tag.
+
+ it, err := ie.tagIndex.Get(ii, tagId)
+ if err != nil {
+ if log.Is(err, ErrTagNotFound) == true {
+ ifdEnumerateLogger.Warningf(nil, "Tag (0x%04x) is not known and will be skipped.", tagId)
+
+ ite = &IfdTagEntry{
+ tagId: tagId,
+ }
+
+ return ite, ErrTagNotFound
+ }
+
+ log.Panic(err)
+ }
+
+ // If we're trying to be as forgiving as possible then use whatever type was
+ // reported in the format. Otherwise, only accept a type that's expected for
+ // this tag.
+ if ie.tagIndex.UniversalSearch() == false && it.DoesSupportType(tagType) == false {
+ // The type in the stream disagrees with the type that this tag is
+ // expected to have. This can present issues with how we handle the
+ // special-case tags (e.g. thumbnails, GPS, etc..) when those tags
+ // suddenly have data that we no longer manipulate correctly/
+ // accurately.
+ ifdEnumerateLogger.Warningf(nil,
+ "Tag (0x%04x) in IFD [%s] at position (%d) has unsupported type (0x%02x) and will be skipped.",
+ tagId, ii, tagPosition, int(tagType))
+
+ return nil, ErrTagTypeNotValid
+ }
+
+ // Construct tag struct.
+
+ rs, err := ie.ebs.GetReadSeeker(0)
+ log.PanicIf(err)
+
+ ite = newIfdTagEntry(
+ ii,
+ tagId,
+ tagPosition,
+ tagType,
+ unitCount,
+ valueOffset,
+ rawValueOffset,
+ rs,
+ ie.byteOrder)
+
+ ifdPath := ii.UnindexedString()
+
+ // If it's an IFD but not a standard one, it'll just be seen as a LONG
+ // (the standard IFD tag type), later, unless we skip it because it's
+ // [likely] not even in the standard list of known tags.
+ mi, err := ie.ifdMapping.GetChild(ifdPath, tagId)
+ if err == nil {
+ currentIfdTag := ii.IfdTag()
+
+ childIt := exifcommon.NewIfdTag(&currentIfdTag, tagId, mi.Name)
+ iiChild := ii.NewChild(childIt, 0)
+ ite.SetChildIfd(iiChild)
+
+ // We also need to set `tag.ChildFqIfdPath` but can't do it here
+ // because we don't have the IFD index.
+ } else if log.Is(err, exifcommon.ErrChildIfdNotMapped) == false {
+ log.Panic(err)
+ }
+
+ return ite, nil
+}
+
+// TagVisitorFn is called for each tag when enumerating through the EXIF.
+type TagVisitorFn func(ite *IfdTagEntry) (err error)
+
+// tagPostParse do some tag-level processing here following the parse of each.
+func (ie *IfdEnumerate) tagPostParse(ite *IfdTagEntry, med *MiscellaneousExifData) (err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ // TODO(dustin): Add test
+
+ ii := ite.IfdIdentity()
+
+ tagId := ite.TagId()
+ tagType := ite.TagType()
+
+ it, err := ie.tagIndex.Get(ii, tagId)
+ if err == nil {
+ ite.setTagName(it.Name)
+ } else {
+ if err != ErrTagNotFound {
+ log.Panic(err)
+ }
+
+ // This is an unknown tag.
+
+ originalBt := exifcommon.BasicTag{
+ FqIfdPath: ii.String(),
+ IfdPath: ii.UnindexedString(),
+ TagId: tagId,
+ }
+
+ if med != nil {
+ med.unknownTags[originalBt] = exifcommon.BasicTag{}
+ }
+
+ utilityLogger.Debugf(nil,
+ "Tag (0x%04x) is not valid for IFD [%s]. Attempting secondary "+
+ "lookup.", tagId, ii.String())
+
+ // This will overwrite the existing `it` and `err`. Since `FindFirst()`
+ // might generate different Errors than `Get()`, the log message above
+ // is import to try and mitigate confusion in that case.
+ it, err = ie.tagIndex.FindFirst(tagId, tagType, nil)
+ if err != nil {
+ if err != ErrTagNotFound {
+ log.Panic(err)
+ }
+
+ // This is supposed to be a convenience function and if we were
+ // to keep the name empty or set it to some placeholder, it
+ // might be mismanaged by the package that is calling us. If
+ // they want to specifically manage these types of tags, they
+ // can use more advanced functionality to specifically -handle
+ // unknown tags.
+ utilityLogger.Warningf(nil,
+ "Tag with ID (0x%04x) in IFD [%s] is not recognized and "+
+ "will be ignored.", tagId, ii.String())
+
+ return ErrTagNotFound
+ }
+
+ ite.setTagName(it.Name)
+
+ utilityLogger.Warningf(nil,
+ "Tag with ID (0x%04x) is not valid for IFD [%s], but it *is* "+
+ "valid as tag [%s] under IFD [%s] and has the same type "+
+ "[%s], so we will use that. This EXIF blob was probably "+
+ "written by a buggy implementation.",
+ tagId, ii.UnindexedString(), it.Name, it.IfdPath,
+ tagType)
+
+ if med != nil {
+ med.unknownTags[originalBt] = exifcommon.BasicTag{
+ IfdPath: it.IfdPath,
+ TagId: tagId,
+ }
+ }
+ }
+
+ // This is a known tag (from the standard, unless the user did
+ // something different).
+
+ // Skip any tags that have a type that doesn't match the type in the
+ // index (which is loaded with the standard and accept tag
+ // information unless configured otherwise).
+ //
+ // We've run into multiple instances of the same tag, where a) no
+ // tag should ever be repeated, and b) all but one had an incorrect
+ // type and caused parsing/conversion woes. So, this is a quick fix
+ // for those scenarios.
+ if ie.tagIndex.UniversalSearch() == false && it.DoesSupportType(tagType) == false {
+ ifdEnumerateLogger.Warningf(nil,
+ "Skipping tag [%s] (0x%04x) [%s] with an unexpected type: %v ∉ %v",
+ ii.UnindexedString(), tagId, it.Name,
+ tagType, it.SupportedTypes)
+
+ return ErrTagNotFound
+ }
+
+ return nil
+}
+
+// parseIfd decodes the IFD block that we're currently sitting on the first
+// byte of.
+func (ie *IfdEnumerate) parseIfd(ii *exifcommon.IfdIdentity, bp *byteParser, visitor TagVisitorFn, doDescend bool, med *MiscellaneousExifData) (nextIfdOffset uint32, entries []*IfdTagEntry, thumbnailData []byte, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ tagCount, _, err := bp.getUint16()
+ log.PanicIf(err)
+
+ ifdEnumerateLogger.Debugf(nil, "IFD [%s] tag-count: (%d)", ii.String(), tagCount)
+
+ entries = make([]*IfdTagEntry, 0)
+
+ var enumeratorThumbnailOffset *IfdTagEntry
+ var enumeratorThumbnailSize *IfdTagEntry
+
+ for i := 0; i < int(tagCount); i++ {
+ ite, err := ie.parseTag(ii, i, bp)
+ if err != nil {
+ if log.Is(err, ErrTagNotFound) == true || log.Is(err, ErrTagTypeNotValid) == true {
+ // These tags should've been fully logged in parseTag(). The
+ // ITE returned is nil so we can't print anything about them, now.
+ continue
+ }
+
+ log.Panic(err)
+ }
+
+ err = ie.tagPostParse(ite, med)
+ if err == nil {
+ if err == ErrTagNotFound {
+ continue
+ }
+
+ log.PanicIf(err)
+ }
+
+ tagId := ite.TagId()
+
+ if visitor != nil {
+ err := visitor(ite)
+ log.PanicIf(err)
+ }
+
+ if ite.IsThumbnailOffset() == true {
+ ifdEnumerateLogger.Debugf(nil, "Skipping the thumbnail offset tag (0x%04x). Use accessors to get it or set it.", tagId)
+
+ enumeratorThumbnailOffset = ite
+ entries = append(entries, ite)
+
+ continue
+ } else if ite.IsThumbnailSize() == true {
+ ifdEnumerateLogger.Debugf(nil, "Skipping the thumbnail size tag (0x%04x). Use accessors to get it or set it.", tagId)
+
+ enumeratorThumbnailSize = ite
+ entries = append(entries, ite)
+
+ continue
+ }
+
+ if ite.TagType() != exifcommon.TypeUndefined {
+ // If this tag's value is an offset, bump our max-offset value to
+ // what that offset is plus however large that value is.
+
+ vc := ite.getValueContext()
+
+ farOffset, err := vc.GetFarOffset()
+ if err == nil {
+ candidateOffset := farOffset + uint32(vc.SizeInBytes())
+ if candidateOffset > ie.furthestOffset {
+ ie.furthestOffset = candidateOffset
+ }
+ } else if err != exifcommon.ErrNotFarValue {
+ log.PanicIf(err)
+ }
+ }
+
+ // If it's an IFD but not a standard one, it'll just be seen as a LONG
+ // (the standard IFD tag type), later, unless we skip it because it's
+ // [likely] not even in the standard list of known tags.
+ if ite.ChildIfdPath() != "" {
+ if doDescend == true {
+ ifdEnumerateLogger.Debugf(nil, "Descending from IFD [%s] to IFD [%s].", ii, ite.ChildIfdPath())
+
+ currentIfdTag := ii.IfdTag()
+
+ childIfdTag :=
+ exifcommon.NewIfdTag(
+ &currentIfdTag,
+ ite.TagId(),
+ ite.ChildIfdName())
+
+ iiChild := ii.NewChild(childIfdTag, 0)
+
+ err := ie.scan(iiChild, ite.getValueOffset(), visitor, med)
+ log.PanicIf(err)
+
+ ifdEnumerateLogger.Debugf(nil, "Ascending from IFD [%s] to IFD [%s].", ite.ChildIfdPath(), ii)
+ }
+ }
+
+ entries = append(entries, ite)
+ }
+
+ if enumeratorThumbnailOffset != nil && enumeratorThumbnailSize != nil {
+ thumbnailData, err = ie.parseThumbnail(enumeratorThumbnailOffset, enumeratorThumbnailSize)
+ if err != nil {
+ ifdEnumerateLogger.Errorf(
+ nil, err,
+ "We tried to bump our furthest-offset counter but there was an issue first seeking past the thumbnail.")
+ } else {
+ // In this case, the value is always an offset.
+ offset := enumeratorThumbnailOffset.getValueOffset()
+
+ // This this case, the value is always a length.
+ length := enumeratorThumbnailSize.getValueOffset()
+
+ ifdEnumerateLogger.Debugf(nil, "Found thumbnail in IFD [%s]. Its offset is (%d) and is (%d) bytes.", ii, offset, length)
+
+ furthestOffset := offset + length
+
+ if furthestOffset > ie.furthestOffset {
+ ie.furthestOffset = furthestOffset
+ }
+ }
+ }
+
+ nextIfdOffset, _, err = bp.getUint32()
+ log.PanicIf(err)
+
+ _, alreadyVisited := ie.visitedIfdOffsets[nextIfdOffset]
+
+ if alreadyVisited == true {
+ ifdEnumerateLogger.Warningf(nil, "IFD at offset (0x%08x) has been linked-to more than once. There might be a cycle in the IFD chain. Not reparsing.", nextIfdOffset)
+ nextIfdOffset = 0
+ }
+
+ if nextIfdOffset != 0 {
+ ie.visitedIfdOffsets[nextIfdOffset] = struct{}{}
+ ifdEnumerateLogger.Debugf(nil, "[%s] Next IFD at offset: (0x%08x)", ii.String(), nextIfdOffset)
+ } else {
+ ifdEnumerateLogger.Debugf(nil, "[%s] IFD chain has terminated.", ii.String())
+ }
+
+ return nextIfdOffset, entries, thumbnailData, nil
+}
+
+func (ie *IfdEnumerate) parseThumbnail(offsetIte, lengthIte *IfdTagEntry) (thumbnailData []byte, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ vRaw, err := lengthIte.Value()
+ log.PanicIf(err)
+
+ vList := vRaw.([]uint32)
+ if len(vList) != 1 {
+ log.Panicf("not exactly one long: (%d)", len(vList))
+ }
+
+ length := vList[0]
+
+ // The tag is official a LONG type, but it's actually an offset to a blob of bytes.
+ offsetIte.updateTagType(exifcommon.TypeByte)
+ offsetIte.updateUnitCount(length)
+
+ thumbnailData, err = offsetIte.GetRawBytes()
+ log.PanicIf(err)
+
+ return thumbnailData, nil
+}
+
+// scan parses and enumerates the different IFD blocks and invokes a visitor
+// callback for each tag. No information is kept or returned.
+func (ie *IfdEnumerate) scan(iiGeneral *exifcommon.IfdIdentity, ifdOffset uint32, visitor TagVisitorFn, med *MiscellaneousExifData) (err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ // TODO(dustin): Add test
+
+ for ifdIndex := 0; ; ifdIndex++ {
+ iiSibling := iiGeneral.NewSibling(ifdIndex)
+
+ ifdEnumerateLogger.Debugf(nil, "Parsing IFD [%s] at offset (0x%04x) (scan).", iiSibling.String(), ifdOffset)
+
+ bp, err := ie.getByteParser(ifdOffset)
+ if err != nil {
+ if err == ErrOffsetInvalid {
+ ifdEnumerateLogger.Errorf(nil, nil, "IFD [%s] at offset (0x%04x) is unreachable. Terminating scan.", iiSibling.String(), ifdOffset)
+ break
+ }
+
+ log.Panic(err)
+ }
+
+ nextIfdOffset, _, _, err := ie.parseIfd(iiSibling, bp, visitor, true, med)
+ log.PanicIf(err)
+
+ currentOffset := bp.CurrentOffset()
+ if currentOffset > ie.furthestOffset {
+ ie.furthestOffset = currentOffset
+ }
+
+ if nextIfdOffset == 0 {
+ break
+ }
+
+ ifdOffset = nextIfdOffset
+ }
+
+ return nil
+}
+
+// MiscellaneousExifData is reports additional data collected during the parse.
+type MiscellaneousExifData struct {
+ // UnknownTags contains all tags that were invalid for their containing
+ // IFDs. The values represent alternative IFDs that were correctly matched
+ // to those tags and used instead.
+ unknownTags map[exifcommon.BasicTag]exifcommon.BasicTag
+}
+
+// UnknownTags returns the unknown tags encountered during the scan.
+func (med *MiscellaneousExifData) UnknownTags() map[exifcommon.BasicTag]exifcommon.BasicTag {
+ return med.unknownTags
+}
+
+// ScanOptions tweaks parser behavior/choices.
+type ScanOptions struct {
+ // NOTE(dustin): Reserved for future usage.
+}
+
+// Scan enumerates the different EXIF blocks (called IFDs). `rootIfdName` will
+// be "IFD" in the TIFF standard.
+func (ie *IfdEnumerate) Scan(iiRoot *exifcommon.IfdIdentity, ifdOffset uint32, visitor TagVisitorFn, so *ScanOptions) (med *MiscellaneousExifData, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ // TODO(dustin): Add test
+
+ med = &MiscellaneousExifData{
+ unknownTags: make(map[exifcommon.BasicTag]exifcommon.BasicTag),
+ }
+
+ err = ie.scan(iiRoot, ifdOffset, visitor, med)
+ log.PanicIf(err)
+
+ ifdEnumerateLogger.Debugf(nil, "Scan: It looks like the furthest offset that contained EXIF data in the EXIF blob was (%d) (Scan).", ie.FurthestOffset())
+
+ return med, nil
+}
+
+// Ifd represents a single, parsed IFD.
+type Ifd struct {
+ ifdIdentity *exifcommon.IfdIdentity
+
+ ifdMapping *exifcommon.IfdMapping
+ tagIndex *TagIndex
+
+ offset uint32
+ byteOrder binary.ByteOrder
+ id int
+
+ parentIfd *Ifd
+
+ // ParentTagIndex is our tag position in the parent IFD, if we had a parent
+ // (if `ParentIfd` is not nil and we weren't an IFD referenced as a sibling
+ // instead of as a child).
+ parentTagIndex int
+
+ entries []*IfdTagEntry
+ entriesByTagId map[uint16][]*IfdTagEntry
+
+ children []*Ifd
+ childIfdIndex map[string]*Ifd
+
+ thumbnailData []byte
+
+ nextIfdOffset uint32
+ nextIfd *Ifd
+}
+
+// IfdIdentity returns IFD identity that this struct represents.
+func (ifd *Ifd) IfdIdentity() *exifcommon.IfdIdentity {
+ return ifd.ifdIdentity
+}
+
+// Entries returns a flat list of all tags for this IFD.
+func (ifd *Ifd) Entries() []*IfdTagEntry {
+
+ // TODO(dustin): Add test
+
+ return ifd.entries
+}
+
+// EntriesByTagId returns a map of all tags for this IFD.
+func (ifd *Ifd) EntriesByTagId() map[uint16][]*IfdTagEntry {
+
+ // TODO(dustin): Add test
+
+ return ifd.entriesByTagId
+}
+
+// Children returns a flat list of all child IFDs of this IFD.
+func (ifd *Ifd) Children() []*Ifd {
+
+ // TODO(dustin): Add test
+
+ return ifd.children
+}
+
+// ChildWithIfdPath returns a map of all child IFDs of this IFD.
+func (ifd *Ifd) ChildIfdIndex() map[string]*Ifd {
+
+ // TODO(dustin): Add test
+
+ return ifd.childIfdIndex
+}
+
+// ParentTagIndex returns the position of this IFD's tag in its parent IFD (*if*
+// there is a parent).
+func (ifd *Ifd) ParentTagIndex() int {
+
+ // TODO(dustin): Add test
+
+ return ifd.parentTagIndex
+}
+
+// Offset returns the offset of the IFD in the stream.
+func (ifd *Ifd) Offset() uint32 {
+
+ // TODO(dustin): Add test
+
+ return ifd.offset
+}
+
+// Offset returns the offset of the IFD in the stream.
+func (ifd *Ifd) ByteOrder() binary.ByteOrder {
+
+ // TODO(dustin): Add test
+
+ return ifd.byteOrder
+}
+
+// NextIfd returns the Ifd struct for the next IFD in the chain.
+func (ifd *Ifd) NextIfd() *Ifd {
+
+ // TODO(dustin): Add test
+
+ return ifd.nextIfd
+}
+
+// ChildWithIfdPath returns an `Ifd` struct for the given child of the current
+// IFD.
+func (ifd *Ifd) ChildWithIfdPath(iiChild *exifcommon.IfdIdentity) (childIfd *Ifd, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ // TODO(dustin): This is a bridge while we're introducing the IFD type-system. We should be able to use the (IfdIdentity).Equals() method for this.
+ ifdPath := iiChild.UnindexedString()
+
+ for _, childIfd := range ifd.children {
+ if childIfd.ifdIdentity.UnindexedString() == ifdPath {
+ return childIfd, nil
+ }
+ }
+
+ log.Panic(ErrTagNotFound)
+ return nil, nil
+}
+
+// FindTagWithId returns a list of tags (usually just zero or one) that match
+// the given tag ID. This is efficient.
+func (ifd *Ifd) FindTagWithId(tagId uint16) (results []*IfdTagEntry, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ results, found := ifd.entriesByTagId[tagId]
+ if found != true {
+ log.Panic(ErrTagNotFound)
+ }
+
+ return results, nil
+}
+
+// FindTagWithName returns a list of tags (usually just zero or one) that match
+// the given tag name. This is not efficient (though the labor is trivial).
+func (ifd *Ifd) FindTagWithName(tagName string) (results []*IfdTagEntry, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ it, err := ifd.tagIndex.GetWithName(ifd.ifdIdentity, tagName)
+ if log.Is(err, ErrTagNotFound) == true {
+ log.Panic(ErrTagNotKnown)
+ } else if err != nil {
+ log.Panic(err)
+ }
+
+ results = make([]*IfdTagEntry, 0)
+ for _, ite := range ifd.entries {
+ if ite.TagId() == it.Id {
+ results = append(results, ite)
+ }
+ }
+
+ if len(results) == 0 {
+ log.Panic(ErrTagNotFound)
+ }
+
+ return results, nil
+}
+
+// String returns a description string.
+func (ifd *Ifd) String() string {
+ parentOffset := uint32(0)
+ if ifd.parentIfd != nil {
+ parentOffset = ifd.parentIfd.offset
+ }
+
+ return fmt.Sprintf("Ifd<ID=(%d) IFD-PATH=[%s] INDEX=(%d) COUNT=(%d) OFF=(0x%04x) CHILDREN=(%d) PARENT=(0x%04x) NEXT-IFD=(0x%04x)>", ifd.id, ifd.ifdIdentity.UnindexedString(), ifd.ifdIdentity.Index(), len(ifd.entries), ifd.offset, len(ifd.children), parentOffset, ifd.nextIfdOffset)
+}
+
+// Thumbnail returns the raw thumbnail bytes. This is typically directly
+// readable by any standard image viewer.
+func (ifd *Ifd) Thumbnail() (data []byte, err error) {
+
+ if ifd.thumbnailData == nil {
+ return nil, ErrNoThumbnail
+ }
+
+ return ifd.thumbnailData, nil
+}
+
+// dumpTags recursively builds a list of tags from an IFD.
+func (ifd *Ifd) dumpTags(tags []*IfdTagEntry) []*IfdTagEntry {
+ if tags == nil {
+ tags = make([]*IfdTagEntry, 0)
+ }
+
+ // Now, print the tags while also descending to child-IFDS as we encounter them.
+
+ ifdsFoundCount := 0
+
+ for _, ite := range ifd.entries {
+ tags = append(tags, ite)
+
+ childIfdPath := ite.ChildIfdPath()
+ if childIfdPath != "" {
+ ifdsFoundCount++
+
+ childIfd, found := ifd.childIfdIndex[childIfdPath]
+ if found != true {
+ log.Panicf("alien child IFD referenced by a tag: [%s]", childIfdPath)
+ }
+
+ tags = childIfd.dumpTags(tags)
+ }
+ }
+
+ if len(ifd.children) != ifdsFoundCount {
+ log.Panicf("have one or more dangling child IFDs: (%d) != (%d)", len(ifd.children), ifdsFoundCount)
+ }
+
+ if ifd.nextIfd != nil {
+ tags = ifd.nextIfd.dumpTags(tags)
+ }
+
+ return tags
+}
+
+// DumpTags prints the IFD hierarchy.
+func (ifd *Ifd) DumpTags() []*IfdTagEntry {
+ return ifd.dumpTags(nil)
+}
+
+func (ifd *Ifd) printTagTree(populateValues bool, index, level int, nextLink bool) {
+ indent := strings.Repeat(" ", level*2)
+
+ prefix := " "
+ if nextLink {
+ prefix = ">"
+ }
+
+ fmt.Printf("%s%sIFD: %s\n", indent, prefix, ifd)
+
+ // Now, print the tags while also descending to child-IFDS as we encounter them.
+
+ ifdsFoundCount := 0
+
+ for _, ite := range ifd.entries {
+ if ite.ChildIfdPath() != "" {
+ fmt.Printf("%s - TAG: %s\n", indent, ite)
+ } else {
+ // This will just add noise to the output (byte-tags are fully
+ // dumped).
+ if ite.IsThumbnailOffset() == true || ite.IsThumbnailSize() == true {
+ continue
+ }
+
+ it, err := ifd.tagIndex.Get(ifd.ifdIdentity, ite.TagId())
+
+ tagName := ""
+ if err == nil {
+ tagName = it.Name
+ }
+
+ var valuePhrase string
+ if populateValues == true {
+ var err error
+
+ valuePhrase, err = ite.Format()
+ if err != nil {
+ if log.Is(err, exifcommon.ErrUnhandledUndefinedTypedTag) == true {
+ ifdEnumerateLogger.Warningf(nil, "Skipping non-standard undefined tag: [%s] (%04x)", ifd.ifdIdentity.UnindexedString(), ite.TagId())
+ continue
+ } else if err == exifundefined.ErrUnparseableValue {
+ ifdEnumerateLogger.Warningf(nil, "Skipping unparseable undefined tag: [%s] (%04x) [%s]", ifd.ifdIdentity.UnindexedString(), ite.TagId(), it.Name)
+ continue
+ }
+
+ log.Panic(err)
+ }
+ } else {
+ valuePhrase = "!UNRESOLVED"
+ }
+
+ fmt.Printf("%s - TAG: %s NAME=[%s] VALUE=[%v]\n", indent, ite, tagName, valuePhrase)
+ }
+
+ childIfdPath := ite.ChildIfdPath()
+ if childIfdPath != "" {
+ ifdsFoundCount++
+
+ childIfd, found := ifd.childIfdIndex[childIfdPath]
+ if found != true {
+ log.Panicf("alien child IFD referenced by a tag: [%s]", childIfdPath)
+ }
+
+ childIfd.printTagTree(populateValues, 0, level+1, false)
+ }
+ }
+
+ if len(ifd.children) != ifdsFoundCount {
+ log.Panicf("have one or more dangling child IFDs: (%d) != (%d)", len(ifd.children), ifdsFoundCount)
+ }
+
+ if ifd.nextIfd != nil {
+ ifd.nextIfd.printTagTree(populateValues, index+1, level, true)
+ }
+}
+
+// PrintTagTree prints the IFD hierarchy.
+func (ifd *Ifd) PrintTagTree(populateValues bool) {
+ ifd.printTagTree(populateValues, 0, 0, false)
+}
+
+func (ifd *Ifd) printIfdTree(level int, nextLink bool) {
+ indent := strings.Repeat(" ", level*2)
+
+ prefix := " "
+ if nextLink {
+ prefix = ">"
+ }
+
+ fmt.Printf("%s%s%s\n", indent, prefix, ifd)
+
+ // Now, print the tags while also descending to child-IFDS as we encounter them.
+
+ ifdsFoundCount := 0
+
+ for _, ite := range ifd.entries {
+ childIfdPath := ite.ChildIfdPath()
+ if childIfdPath != "" {
+ ifdsFoundCount++
+
+ childIfd, found := ifd.childIfdIndex[childIfdPath]
+ if found != true {
+ log.Panicf("alien child IFD referenced by a tag: [%s]", childIfdPath)
+ }
+
+ childIfd.printIfdTree(level+1, false)
+ }
+ }
+
+ if len(ifd.children) != ifdsFoundCount {
+ log.Panicf("have one or more dangling child IFDs: (%d) != (%d)", len(ifd.children), ifdsFoundCount)
+ }
+
+ if ifd.nextIfd != nil {
+ ifd.nextIfd.printIfdTree(level, true)
+ }
+}
+
+// PrintIfdTree prints the IFD hierarchy.
+func (ifd *Ifd) PrintIfdTree() {
+ ifd.printIfdTree(0, false)
+}
+
+func (ifd *Ifd) dumpTree(tagsDump []string, level int) []string {
+ if tagsDump == nil {
+ tagsDump = make([]string, 0)
+ }
+
+ indent := strings.Repeat(" ", level*2)
+
+ var ifdPhrase string
+ if ifd.parentIfd != nil {
+ ifdPhrase = fmt.Sprintf("[%s]->[%s]:(%d)", ifd.parentIfd.ifdIdentity.UnindexedString(), ifd.ifdIdentity.UnindexedString(), ifd.ifdIdentity.Index())
+ } else {
+ ifdPhrase = fmt.Sprintf("[ROOT]->[%s]:(%d)", ifd.ifdIdentity.UnindexedString(), ifd.ifdIdentity.Index())
+ }
+
+ startBlurb := fmt.Sprintf("%s> IFD %s TOP", indent, ifdPhrase)
+ tagsDump = append(tagsDump, startBlurb)
+
+ ifdsFoundCount := 0
+ for _, ite := range ifd.entries {
+ tagsDump = append(tagsDump, fmt.Sprintf("%s - (0x%04x)", indent, ite.TagId()))
+
+ childIfdPath := ite.ChildIfdPath()
+ if childIfdPath != "" {
+ ifdsFoundCount++
+
+ childIfd, found := ifd.childIfdIndex[childIfdPath]
+ if found != true {
+ log.Panicf("alien child IFD referenced by a tag: [%s]", childIfdPath)
+ }
+
+ tagsDump = childIfd.dumpTree(tagsDump, level+1)
+ }
+ }
+
+ if len(ifd.children) != ifdsFoundCount {
+ log.Panicf("have one or more dangling child IFDs: (%d) != (%d)", len(ifd.children), ifdsFoundCount)
+ }
+
+ finishBlurb := fmt.Sprintf("%s< IFD %s BOTTOM", indent, ifdPhrase)
+ tagsDump = append(tagsDump, finishBlurb)
+
+ if ifd.nextIfd != nil {
+ siblingBlurb := fmt.Sprintf("%s* LINKING TO SIBLING IFD [%s]:(%d)", indent, ifd.nextIfd.ifdIdentity.UnindexedString(), ifd.nextIfd.ifdIdentity.Index())
+ tagsDump = append(tagsDump, siblingBlurb)
+
+ tagsDump = ifd.nextIfd.dumpTree(tagsDump, level)
+ }
+
+ return tagsDump
+}
+
+// DumpTree returns a list of strings describing the IFD hierarchy.
+func (ifd *Ifd) DumpTree() []string {
+ return ifd.dumpTree(nil, 0)
+}
+
+// GpsInfo parses and consolidates the GPS info. This can only be called on the
+// GPS IFD.
+func (ifd *Ifd) GpsInfo() (gi *GpsInfo, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ gi = new(GpsInfo)
+
+ if ifd.ifdIdentity.Equals(exifcommon.IfdGpsInfoStandardIfdIdentity) == false {
+ log.Panicf("GPS can only be read on GPS IFD: [%s]", ifd.ifdIdentity.UnindexedString())
+ }
+
+ if tags, found := ifd.entriesByTagId[TagGpsVersionId]; found == false {
+ // We've seen this. We'll just have to default to assuming we're in a
+ // 2.2.0.0 format.
+ ifdEnumerateLogger.Warningf(nil, "No GPS version tag (0x%04x) found.", TagGpsVersionId)
+ } else {
+ versionBytes, err := tags[0].GetRawBytes()
+ log.PanicIf(err)
+
+ hit := false
+ for _, acceptedGpsVersion := range ValidGpsVersions {
+ if bytes.Compare(versionBytes, acceptedGpsVersion[:]) == 0 {
+ hit = true
+ break
+ }
+ }
+
+ if hit != true {
+ ifdEnumerateLogger.Warningf(nil, "GPS version not supported: %v", versionBytes)
+ log.Panic(ErrNoGpsTags)
+ }
+ }
+
+ tags, found := ifd.entriesByTagId[TagLatitudeId]
+ if found == false {
+ ifdEnumerateLogger.Warningf(nil, "latitude not found")
+ log.Panic(ErrNoGpsTags)
+ }
+
+ latitudeValue, err := tags[0].Value()
+ log.PanicIf(err)
+
+ // Look for whether North or South.
+ tags, found = ifd.entriesByTagId[TagLatitudeRefId]
+ if found == false {
+ ifdEnumerateLogger.Warningf(nil, "latitude-ref not found")
+ log.Panic(ErrNoGpsTags)
+ }
+
+ latitudeRefValue, err := tags[0].Value()
+ log.PanicIf(err)
+
+ tags, found = ifd.entriesByTagId[TagLongitudeId]
+ if found == false {
+ ifdEnumerateLogger.Warningf(nil, "longitude not found")
+ log.Panic(ErrNoGpsTags)
+ }
+
+ longitudeValue, err := tags[0].Value()
+ log.PanicIf(err)
+
+ // Look for whether West or East.
+ tags, found = ifd.entriesByTagId[TagLongitudeRefId]
+ if found == false {
+ ifdEnumerateLogger.Warningf(nil, "longitude-ref not found")
+ log.Panic(ErrNoGpsTags)
+ }
+
+ longitudeRefValue, err := tags[0].Value()
+ log.PanicIf(err)
+
+ // Parse location.
+
+ latitudeRaw := latitudeValue.([]exifcommon.Rational)
+
+ gi.Latitude, err = NewGpsDegreesFromRationals(latitudeRefValue.(string), latitudeRaw)
+ log.PanicIf(err)
+
+ longitudeRaw := longitudeValue.([]exifcommon.Rational)
+
+ gi.Longitude, err = NewGpsDegreesFromRationals(longitudeRefValue.(string), longitudeRaw)
+ log.PanicIf(err)
+
+ // Parse altitude.
+
+ altitudeTags, foundAltitude := ifd.entriesByTagId[TagAltitudeId]
+ altitudeRefTags, foundAltitudeRef := ifd.entriesByTagId[TagAltitudeRefId]
+
+ if foundAltitude == true && foundAltitudeRef == true {
+ altitudePhrase, err := altitudeTags[0].Format()
+ log.PanicIf(err)
+
+ ifdEnumerateLogger.Debugf(nil, "Altitude is [%s].", altitudePhrase)
+
+ altitudeValue, err := altitudeTags[0].Value()
+ log.PanicIf(err)
+
+ altitudeRefPhrase, err := altitudeRefTags[0].Format()
+ log.PanicIf(err)
+
+ ifdEnumerateLogger.Debugf(nil, "Altitude-reference is [%s].", altitudeRefPhrase)
+
+ altitudeRefValue, err := altitudeRefTags[0].Value()
+ log.PanicIf(err)
+
+ altitudeRaw := altitudeValue.([]exifcommon.Rational)
+ if altitudeRaw[0].Denominator > 0 {
+ altitude := int(altitudeRaw[0].Numerator / altitudeRaw[0].Denominator)
+
+ if altitudeRefValue.([]byte)[0] == 1 {
+ altitude *= -1
+ }
+
+ gi.Altitude = altitude
+ }
+ }
+
+ // Parse timestamp from separate date and time tags.
+
+ timestampTags, foundTimestamp := ifd.entriesByTagId[TagTimestampId]
+ datestampTags, foundDatestamp := ifd.entriesByTagId[TagDatestampId]
+
+ if foundTimestamp == true && foundDatestamp == true {
+ datestampValue, err := datestampTags[0].Value()
+ log.PanicIf(err)
+
+ datePhrase := datestampValue.(string)
+ ifdEnumerateLogger.Debugf(nil, "Date tag value is [%s].", datePhrase)
+
+ // Normalize the separators.
+ datePhrase = strings.ReplaceAll(datePhrase, "-", ":")
+
+ dateParts := strings.Split(datePhrase, ":")
+
+ year, err1 := strconv.ParseUint(dateParts[0], 10, 16)
+ month, err2 := strconv.ParseUint(dateParts[1], 10, 8)
+ day, err3 := strconv.ParseUint(dateParts[2], 10, 8)
+
+ if err1 == nil && err2 == nil && err3 == nil {
+ timestampValue, err := timestampTags[0].Value()
+ log.PanicIf(err)
+
+ timePhrase, err := timestampTags[0].Format()
+ log.PanicIf(err)
+
+ ifdEnumerateLogger.Debugf(nil, "Time tag value is [%s].", timePhrase)
+
+ timestampRaw := timestampValue.([]exifcommon.Rational)
+
+ hour := int(timestampRaw[0].Numerator / timestampRaw[0].Denominator)
+ minute := int(timestampRaw[1].Numerator / timestampRaw[1].Denominator)
+ second := int(timestampRaw[2].Numerator / timestampRaw[2].Denominator)
+
+ gi.Timestamp = time.Date(int(year), time.Month(month), int(day), hour, minute, second, 0, time.UTC)
+ }
+ }
+
+ return gi, nil
+}
+
+// ParsedTagVisitor is a callback used if wanting to visit through all tags and
+// child IFDs from the current IFD and going down.
+type ParsedTagVisitor func(*Ifd, *IfdTagEntry) error
+
+// EnumerateTagsRecursively calls the given visitor function for every tag and
+// IFD in the current IFD, recursively.
+func (ifd *Ifd) EnumerateTagsRecursively(visitor ParsedTagVisitor) (err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ for ptr := ifd; ptr != nil; ptr = ptr.nextIfd {
+ for _, ite := range ifd.entries {
+ childIfdPath := ite.ChildIfdPath()
+ if childIfdPath != "" {
+ childIfd := ifd.childIfdIndex[childIfdPath]
+
+ err := childIfd.EnumerateTagsRecursively(visitor)
+ log.PanicIf(err)
+ } else {
+ err := visitor(ifd, ite)
+ log.PanicIf(err)
+ }
+ }
+ }
+
+ return nil
+}
+
+// QueuedIfd is one IFD that has been identified but yet to be processed.
+type QueuedIfd struct {
+ IfdIdentity *exifcommon.IfdIdentity
+
+ Offset uint32
+ Parent *Ifd
+
+ // ParentTagIndex is our tag position in the parent IFD, if we had a parent
+ // (if `ParentIfd` is not nil and we weren't an IFD referenced as a sibling
+ // instead of as a child).
+ ParentTagIndex int
+}
+
+// IfdIndex collects a bunch of IFD and tag information stored in several
+// different ways in order to provide convenient lookups.
+type IfdIndex struct {
+ RootIfd *Ifd
+ Ifds []*Ifd
+ Tree map[int]*Ifd
+ Lookup map[string]*Ifd
+}
+
+// Collect enumerates the different EXIF blocks (called IFDs) and builds out an
+// index struct for referencing all of the parsed data.
+func (ie *IfdEnumerate) Collect(rootIfdOffset uint32) (index IfdIndex, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ // TODO(dustin): Add MiscellaneousExifData to IfdIndex
+
+ tree := make(map[int]*Ifd)
+ ifds := make([]*Ifd, 0)
+ lookup := make(map[string]*Ifd)
+
+ queue := []QueuedIfd{
+ {
+ IfdIdentity: exifcommon.IfdStandardIfdIdentity,
+ Offset: rootIfdOffset,
+ },
+ }
+
+ edges := make(map[uint32]*Ifd)
+
+ for {
+ if len(queue) == 0 {
+ break
+ }
+
+ qi := queue[0]
+ ii := qi.IfdIdentity
+
+ offset := qi.Offset
+ parentIfd := qi.Parent
+
+ queue = queue[1:]
+
+ ifdEnumerateLogger.Debugf(nil, "Parsing IFD [%s] (%d) at offset (0x%04x) (Collect).", ii.String(), ii.Index(), offset)
+
+ bp, err := ie.getByteParser(offset)
+ if err != nil {
+ if err == ErrOffsetInvalid {
+ return index, err
+ }
+
+ log.Panic(err)
+ }
+
+ // TODO(dustin): We don't need to pass the index in as a separate argument. Get from the II.
+
+ nextIfdOffset, entries, thumbnailData, err := ie.parseIfd(ii, bp, nil, false, nil)
+ log.PanicIf(err)
+
+ currentOffset := bp.CurrentOffset()
+ if currentOffset > ie.furthestOffset {
+ ie.furthestOffset = currentOffset
+ }
+
+ id := len(ifds)
+
+ entriesByTagId := make(map[uint16][]*IfdTagEntry)
+ for _, ite := range entries {
+ tagId := ite.TagId()
+
+ tags, found := entriesByTagId[tagId]
+ if found == false {
+ tags = make([]*IfdTagEntry, 0)
+ }
+
+ entriesByTagId[tagId] = append(tags, ite)
+ }
+
+ ifd := &Ifd{
+ ifdIdentity: ii,
+
+ byteOrder: ie.byteOrder,
+
+ id: id,
+
+ parentIfd: parentIfd,
+ parentTagIndex: qi.ParentTagIndex,
+
+ offset: offset,
+ entries: entries,
+ entriesByTagId: entriesByTagId,
+
+ // This is populated as each child is processed.
+ children: make([]*Ifd, 0),
+
+ nextIfdOffset: nextIfdOffset,
+ thumbnailData: thumbnailData,
+
+ ifdMapping: ie.ifdMapping,
+ tagIndex: ie.tagIndex,
+ }
+
+ // Add ourselves to a big list of IFDs.
+ ifds = append(ifds, ifd)
+
+ // Install ourselves into a by-id lookup table (keys are unique).
+ tree[id] = ifd
+
+ // Install into by-name buckets.
+ lookup[ii.String()] = ifd
+
+ // Add a link from the previous IFD in the chain to us.
+ if previousIfd, found := edges[offset]; found == true {
+ previousIfd.nextIfd = ifd
+ }
+
+ // Attach as a child to our parent (where we appeared as a tag in
+ // that IFD).
+ if parentIfd != nil {
+ parentIfd.children = append(parentIfd.children, ifd)
+ }
+
+ // Determine if any of our entries is a child IFD and queue it.
+ for i, ite := range entries {
+ if ite.ChildIfdPath() == "" {
+ continue
+ }
+
+ tagId := ite.TagId()
+ childIfdName := ite.ChildIfdName()
+
+ currentIfdTag := ii.IfdTag()
+
+ childIfdTag :=
+ exifcommon.NewIfdTag(
+ &currentIfdTag,
+ tagId,
+ childIfdName)
+
+ iiChild := ii.NewChild(childIfdTag, 0)
+
+ qi := QueuedIfd{
+ IfdIdentity: iiChild,
+
+ Offset: ite.getValueOffset(),
+ Parent: ifd,
+ ParentTagIndex: i,
+ }
+
+ queue = append(queue, qi)
+ }
+
+ // If there's another IFD in the chain.
+ if nextIfdOffset != 0 {
+ iiSibling := ii.NewSibling(ii.Index() + 1)
+
+ // Allow the next link to know what the previous link was.
+ edges[nextIfdOffset] = ifd
+
+ qi := QueuedIfd{
+ IfdIdentity: iiSibling,
+ Offset: nextIfdOffset,
+ }
+
+ queue = append(queue, qi)
+ }
+ }
+
+ index.RootIfd = tree[0]
+ index.Ifds = ifds
+ index.Tree = tree
+ index.Lookup = lookup
+
+ err = ie.setChildrenIndex(index.RootIfd)
+ log.PanicIf(err)
+
+ ifdEnumerateLogger.Debugf(nil, "Collect: It looks like the furthest offset that contained EXIF data in the EXIF blob was (%d).", ie.FurthestOffset())
+
+ return index, nil
+}
+
+func (ie *IfdEnumerate) setChildrenIndex(ifd *Ifd) (err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ childIfdIndex := make(map[string]*Ifd)
+ for _, childIfd := range ifd.children {
+ childIfdIndex[childIfd.ifdIdentity.UnindexedString()] = childIfd
+ }
+
+ ifd.childIfdIndex = childIfdIndex
+
+ for _, childIfd := range ifd.children {
+ err := ie.setChildrenIndex(childIfd)
+ log.PanicIf(err)
+ }
+
+ return nil
+}
+
+// FurthestOffset returns the furthest offset visited in the EXIF blob. This
+// *does not* account for the locations of any undefined tags since we always
+// evaluate the furthest offset, whether or not the user wants to know it.
+//
+// We are not willing to incur the cost of actually parsing those tags just to
+// know their length when there are still undefined tags that are out there
+// that we still won't have any idea how to parse, thus making this an
+// approximation regardless of how clever we get.
+func (ie *IfdEnumerate) FurthestOffset() uint32 {
+
+ // TODO(dustin): Add test
+
+ return ie.furthestOffset
+}
+
+// parseOneIfd is a hack to use an IE to parse a raw IFD block. Can be used for
+// testing. The fqIfdPath ("fully-qualified IFD path") will be less qualified
+// in that the numeric index will always be zero (the zeroth child) rather than
+// the proper number (if its actually a sibling to the first child, for
+// instance).
+func parseOneIfd(ifdMapping *exifcommon.IfdMapping, tagIndex *TagIndex, ii *exifcommon.IfdIdentity, byteOrder binary.ByteOrder, ifdBlock []byte, visitor TagVisitorFn) (nextIfdOffset uint32, entries []*IfdTagEntry, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ // TODO(dustin): Add test
+
+ ebs := NewExifReadSeekerWithBytes(ifdBlock)
+
+ rs, err := ebs.GetReadSeeker(0)
+ log.PanicIf(err)
+
+ bp, err := newByteParser(rs, byteOrder, 0)
+ if err != nil {
+ if err == ErrOffsetInvalid {
+ return 0, nil, err
+ }
+
+ log.Panic(err)
+ }
+
+ dummyEbs := NewExifReadSeekerWithBytes([]byte{})
+ ie := NewIfdEnumerate(ifdMapping, tagIndex, dummyEbs, byteOrder)
+
+ nextIfdOffset, entries, _, err = ie.parseIfd(ii, bp, visitor, true, nil)
+ log.PanicIf(err)
+
+ return nextIfdOffset, entries, nil
+}
+
+// parseOneTag is a hack to use an IE to parse a raw tag block.
+func parseOneTag(ifdMapping *exifcommon.IfdMapping, tagIndex *TagIndex, ii *exifcommon.IfdIdentity, byteOrder binary.ByteOrder, tagBlock []byte) (ite *IfdTagEntry, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ // TODO(dustin): Add test
+
+ ebs := NewExifReadSeekerWithBytes(tagBlock)
+
+ rs, err := ebs.GetReadSeeker(0)
+ log.PanicIf(err)
+
+ bp, err := newByteParser(rs, byteOrder, 0)
+ if err != nil {
+ if err == ErrOffsetInvalid {
+ return nil, err
+ }
+
+ log.Panic(err)
+ }
+
+ dummyEbs := NewExifReadSeekerWithBytes([]byte{})
+ ie := NewIfdEnumerate(ifdMapping, tagIndex, dummyEbs, byteOrder)
+
+ ite, err = ie.parseTag(ii, 0, bp)
+ log.PanicIf(err)
+
+ err = ie.tagPostParse(ite, nil)
+ if err != nil {
+ if err == ErrTagNotFound {
+ return nil, err
+ }
+
+ log.Panic(err)
+ }
+
+ return ite, nil
+}
+
+// FindIfdFromRootIfd returns the given `Ifd` given the root-IFD and path of the
+// desired IFD.
+func FindIfdFromRootIfd(rootIfd *Ifd, ifdPath string) (ifd *Ifd, err error) {
+ defer func() {
+ if state := recover(); state != nil {
+ err = log.Wrap(state.(error))
+ }
+ }()
+
+ // TODO(dustin): !! Add test.
+
+ lineage, err := rootIfd.ifdMapping.ResolvePath(ifdPath)
+ log.PanicIf(err)
+
+ // Confirm the first IFD is our root IFD type, and then prune it because
+ // from then on we'll be searching down through our children.
+
+ if len(lineage) == 0 {
+ log.Panicf("IFD path must be non-empty.")
+ } else if lineage[0].Name != exifcommon.IfdStandardIfdIdentity.Name() {
+ log.Panicf("First IFD path item must be [%s].", exifcommon.IfdStandardIfdIdentity.Name())
+ }
+
+ desiredRootIndex := lineage[0].Index
+ lineage = lineage[1:]
+
+ // TODO(dustin): !! This is a poorly conceived fix that just doubles the work we already have to do below, which then interacts badly with the indices not being properly represented in the IFD-phrase.
+ // TODO(dustin): !! <-- However, we're not sure whether we shouldn't store a secondary IFD-path with the indices. Some IFDs may not necessarily restrict which IFD indices they can be a child of (only the IFD itself matters). Validation should be delegated to the caller.
+ thisIfd := rootIfd
+ for currentRootIndex := 0; currentRootIndex < desiredRootIndex; currentRootIndex++ {
+ if thisIfd.nextIfd == nil {
+ log.Panicf("Root-IFD index (%d) does not exist in the data.", currentRootIndex)
+ }
+
+ thisIfd = thisIfd.nextIfd
+ }
+
+ for _, itii := range lineage {
+ var hit *Ifd
+ for _, childIfd := range thisIfd.children {
+ if childIfd.ifdIdentity.TagId() == itii.TagId {
+ hit = childIfd
+ break
+ }
+ }
+
+ // If we didn't find the child, add it.
+ if hit == nil {
+ log.Panicf("IFD [%s] in [%s] not found: %s", itii.Name, ifdPath, thisIfd.children)
+ }
+
+ thisIfd = hit
+
+ // If we didn't find the sibling, add it.
+ for i := 0; i < itii.Index; i++ {
+ if thisIfd.nextIfd == nil {
+ log.Panicf("IFD [%s] does not have (%d) occurrences/siblings", thisIfd.ifdIdentity.UnindexedString(), itii.Index)
+ }
+
+ thisIfd = thisIfd.nextIfd
+ }
+ }
+
+ return thisIfd, nil
+}
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-13 16:25:01 +0000