gotosocial/vendor/github.com/dsoprea/go-exif/v2/common/ifd.go

package exifcommon

import (
	"errors"
	"fmt"
	"strings"

	"github.com/dsoprea/go-logging"
)

var (
	ifdLogger = log.NewLogger("exifcommon.ifd")
)

var (
	ErrChildIfdNotMapped = errors.New("no child-IFD for that tag-ID under parent")
)

// MappedIfd is one node in the IFD-mapping.
type MappedIfd struct {
	ParentTagId uint16
	Placement   []uint16
	Path        []string

	Name     string
	TagId    uint16
	Children map[uint16]*MappedIfd
}

// String returns a descriptive string.
func (mi *MappedIfd) String() string {
	pathPhrase := mi.PathPhrase()
	return fmt.Sprintf("MappedIfd<(0x%04X) [%s] PATH=[%s]>", mi.TagId, mi.Name, pathPhrase)
}

// PathPhrase returns a non-fully-qualified IFD path.
func (mi *MappedIfd) PathPhrase() string {
	return strings.Join(mi.Path, "/")
}

// TODO(dustin): Refactor this to use IfdIdentity structs.

// IfdMapping describes all of the IFDs that we currently recognize.
type IfdMapping struct {
	rootNode *MappedIfd
}

// NewIfdMapping returns a new IfdMapping struct.
func NewIfdMapping() (ifdMapping *IfdMapping) {
	rootNode := &MappedIfd{
		Path:     make([]string, 0),
		Children: make(map[uint16]*MappedIfd),
	}

	return &IfdMapping{
		rootNode: rootNode,
	}
}

// NewIfdMappingWithStandard retruns a new IfdMapping struct preloaded with the
// standard IFDs.
func NewIfdMappingWithStandard() (ifdMapping *IfdMapping) {
	defer func() {
		if state := recover(); state != nil {
			err := log.Wrap(state.(error))
			log.Panic(err)
		}
	}()

	im := NewIfdMapping()

	err := LoadStandardIfds(im)
	log.PanicIf(err)

	return im
}

// Get returns the node given the path slice.
func (im *IfdMapping) Get(parentPlacement []uint16) (childIfd *MappedIfd, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	ptr := im.rootNode
	for _, tagId := range parentPlacement {
		if descendantPtr, found := ptr.Children[tagId]; found == false {
			log.Panicf("ifd child with tag-ID (%04x) not registered: [%s]", tagId, ptr.PathPhrase())
		} else {
			ptr = descendantPtr
		}
	}

	return ptr, nil
}

// GetWithPath returns the node given the path string.
func (im *IfdMapping) GetWithPath(pathPhrase string) (mi *MappedIfd, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	if pathPhrase == "" {
		log.Panicf("path-phrase is empty")
	}

	path := strings.Split(pathPhrase, "/")
	ptr := im.rootNode

	for _, name := range path {
		var hit *MappedIfd
		for _, mi := range ptr.Children {
			if mi.Name == name {
				hit = mi
				break
			}
		}

		if hit == nil {
			log.Panicf("ifd child with name [%s] not registered: [%s]", name, ptr.PathPhrase())
		}

		ptr = hit
	}

	return ptr, nil
}

// GetChild is a convenience function to get the child path for a given parent
// placement and child tag-ID.
func (im *IfdMapping) GetChild(parentPathPhrase string, tagId uint16) (mi *MappedIfd, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	mi, err = im.GetWithPath(parentPathPhrase)
	log.PanicIf(err)

	for _, childMi := range mi.Children {
		if childMi.TagId == tagId {
			return childMi, nil
		}
	}

	// Whether or not an IFD is defined in data, such an IFD is not registered
	// and would be unknown.
	log.Panic(ErrChildIfdNotMapped)
	return nil, nil
}

// IfdTagIdAndIndex represents a specific part of the IFD path.
//
// This is a legacy type.
type IfdTagIdAndIndex struct {
	Name  string
	TagId uint16
	Index int
}

// String returns a descriptive string.
func (itii IfdTagIdAndIndex) String() string {
	return fmt.Sprintf("IfdTagIdAndIndex<NAME=[%s] ID=(%04x) INDEX=(%d)>", itii.Name, itii.TagId, itii.Index)
}

// ResolvePath takes a list of names, which can also be suffixed with indices
// (to identify the second, third, etc.. sibling IFD) and returns a list of
// tag-IDs and those indices.
//
// Example:
//
// - IFD/Exif/Iop
// - IFD0/Exif/Iop
//
// This is the only call that supports adding the numeric indices.
func (im *IfdMapping) ResolvePath(pathPhrase string) (lineage []IfdTagIdAndIndex, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	pathPhrase = strings.TrimSpace(pathPhrase)

	if pathPhrase == "" {
		log.Panicf("can not resolve empty path-phrase")
	}

	path := strings.Split(pathPhrase, "/")
	lineage = make([]IfdTagIdAndIndex, len(path))

	ptr := im.rootNode
	empty := IfdTagIdAndIndex{}
	for i, name := range path {
		indexByte := name[len(name)-1]
		index := 0
		if indexByte >= '0' && indexByte <= '9' {
			index = int(indexByte - '0')
			name = name[:len(name)-1]
		}

		itii := IfdTagIdAndIndex{}
		for _, mi := range ptr.Children {
			if mi.Name != name {
				continue
			}

			itii.Name = name
			itii.TagId = mi.TagId
			itii.Index = index

			ptr = mi

			break
		}

		if itii == empty {
			log.Panicf("ifd child with name [%s] not registered: [%s]", name, pathPhrase)
		}

		lineage[i] = itii
	}

	return lineage, nil
}

// FqPathPhraseFromLineage returns the fully-qualified IFD path from the slice.
func (im *IfdMapping) FqPathPhraseFromLineage(lineage []IfdTagIdAndIndex) (fqPathPhrase string) {
	fqPathParts := make([]string, len(lineage))
	for i, itii := range lineage {
		if itii.Index > 0 {
			fqPathParts[i] = fmt.Sprintf("%s%d", itii.Name, itii.Index)
		} else {
			fqPathParts[i] = itii.Name
		}
	}

	return strings.Join(fqPathParts, "/")
}

// PathPhraseFromLineage returns the non-fully-qualified IFD path from the
// slice.
func (im *IfdMapping) PathPhraseFromLineage(lineage []IfdTagIdAndIndex) (pathPhrase string) {
	pathParts := make([]string, len(lineage))
	for i, itii := range lineage {
		pathParts[i] = itii.Name
	}

	return strings.Join(pathParts, "/")
}

// StripPathPhraseIndices returns a non-fully-qualified path-phrase (no
// indices).
func (im *IfdMapping) StripPathPhraseIndices(pathPhrase string) (strippedPathPhrase string, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	lineage, err := im.ResolvePath(pathPhrase)
	log.PanicIf(err)

	strippedPathPhrase = im.PathPhraseFromLineage(lineage)
	return strippedPathPhrase, nil
}

// Add puts the given IFD at the given position of the tree. The position of the
// tree is referred to as the placement and is represented by a set of tag-IDs,
// where the leftmost is the root tag and the tags going to the right are
// progressive descendants.
func (im *IfdMapping) Add(parentPlacement []uint16, tagId uint16, name string) (err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	// TODO(dustin): !! It would be nicer to provide a list of names in the placement rather than tag-IDs.

	ptr, err := im.Get(parentPlacement)
	log.PanicIf(err)

	path := make([]string, len(parentPlacement)+1)
	if len(parentPlacement) > 0 {
		copy(path, ptr.Path)
	}

	path[len(path)-1] = name

	placement := make([]uint16, len(parentPlacement)+1)
	if len(placement) > 0 {
		copy(placement, ptr.Placement)
	}

	placement[len(placement)-1] = tagId

	childIfd := &MappedIfd{
		ParentTagId: ptr.TagId,
		Path:        path,
		Placement:   placement,
		Name:        name,
		TagId:       tagId,
		Children:    make(map[uint16]*MappedIfd),
	}

	if _, found := ptr.Children[tagId]; found == true {
		log.Panicf("child IFD with tag-ID (%04x) already registered under IFD [%s] with tag-ID (%04x)", tagId, ptr.Name, ptr.TagId)
	}

	ptr.Children[tagId] = childIfd

	return nil
}

func (im *IfdMapping) dumpLineages(stack []*MappedIfd, input []string) (output []string, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	currentIfd := stack[len(stack)-1]

	output = input
	for _, childIfd := range currentIfd.Children {
		stackCopy := make([]*MappedIfd, len(stack)+1)

		copy(stackCopy, stack)
		stackCopy[len(stack)] = childIfd

		// Add to output, but don't include the obligatory root node.
		parts := make([]string, len(stackCopy)-1)
		for i, mi := range stackCopy[1:] {
			parts[i] = mi.Name
		}

		output = append(output, strings.Join(parts, "/"))

		output, err = im.dumpLineages(stackCopy, output)
		log.PanicIf(err)
	}

	return output, nil
}

// DumpLineages returns a slice of strings representing all mappings.
func (im *IfdMapping) DumpLineages() (output []string, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	stack := []*MappedIfd{im.rootNode}
	output = make([]string, 0)

	output, err = im.dumpLineages(stack, output)
	log.PanicIf(err)

	return output, nil
}

// LoadStandardIfds loads the standard IFDs into the mapping.
func LoadStandardIfds(im *IfdMapping) (err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	err = im.Add(
		[]uint16{},
		IfdStandardIfdIdentity.TagId(), IfdStandardIfdIdentity.Name())

	log.PanicIf(err)

	err = im.Add(
		[]uint16{IfdStandardIfdIdentity.TagId()},
		IfdExifStandardIfdIdentity.TagId(), IfdExifStandardIfdIdentity.Name())

	log.PanicIf(err)

	err = im.Add(
		[]uint16{IfdStandardIfdIdentity.TagId(), IfdExifStandardIfdIdentity.TagId()},
		IfdExifIopStandardIfdIdentity.TagId(), IfdExifIopStandardIfdIdentity.Name())

	log.PanicIf(err)

	err = im.Add(
		[]uint16{IfdStandardIfdIdentity.TagId()},
		IfdGpsInfoStandardIfdIdentity.TagId(), IfdGpsInfoStandardIfdIdentity.Name())

	log.PanicIf(err)

	return nil
}

// IfdTag describes a single IFD tag and its parent (if any).
type IfdTag struct {
	parentIfdTag *IfdTag
	tagId        uint16
	name         string
}

func NewIfdTag(parentIfdTag *IfdTag, tagId uint16, name string) IfdTag {
	return IfdTag{
		parentIfdTag: parentIfdTag,
		tagId:        tagId,
		name:         name,
	}
}

// ParentIfd returns the IfdTag of this IFD's parent.
func (it IfdTag) ParentIfd() *IfdTag {
	return it.parentIfdTag
}

// TagId returns the tag-ID of this IFD.
func (it IfdTag) TagId() uint16 {
	return it.tagId
}

// Name returns the simple name of this IFD.
func (it IfdTag) Name() string {
	return it.name
}

// String returns a descriptive string.
func (it IfdTag) String() string {
	parentIfdPhrase := ""
	if it.parentIfdTag != nil {
		parentIfdPhrase = fmt.Sprintf(" PARENT=(0x%04x)[%s]", it.parentIfdTag.tagId, it.parentIfdTag.name)
	}

	return fmt.Sprintf("IfdTag<TAG-ID=(0x%04x) NAME=[%s]%s>", it.tagId, it.name, parentIfdPhrase)
}

var (
	// rootStandardIfd is the standard root IFD.
	rootStandardIfd = NewIfdTag(nil, 0x0000, "IFD") // IFD

	// exifStandardIfd is the standard "Exif" IFD.
	exifStandardIfd = NewIfdTag(&rootStandardIfd, 0x8769, "Exif") // IFD/Exif

	// iopStandardIfd is the standard "Iop" IFD.
	iopStandardIfd = NewIfdTag(&exifStandardIfd, 0xA005, "Iop") // IFD/Exif/Iop

	// gpsInfoStandardIfd is the standard "GPS" IFD.
	gpsInfoStandardIfd = NewIfdTag(&rootStandardIfd, 0x8825, "GPSInfo") // IFD/GPSInfo
)

// IfdIdentityPart represents one component in an IFD path.
type IfdIdentityPart struct {
	Name  string
	Index int
}

// String returns a fully-qualified IFD path.
func (iip IfdIdentityPart) String() string {
	if iip.Index > 0 {
		return fmt.Sprintf("%s%d", iip.Name, iip.Index)
	} else {
		return iip.Name
	}
}

// UnindexedString returned a non-fully-qualified IFD path.
func (iip IfdIdentityPart) UnindexedString() string {
	return iip.Name
}

// IfdIdentity represents a single IFD path and provides access to various
// information and representations.
//
// Only global instances can be used for equality checks.
type IfdIdentity struct {
	ifdTag    IfdTag
	parts     []IfdIdentityPart
	ifdPath   string
	fqIfdPath string
}

// NewIfdIdentity returns a new IfdIdentity struct.
func NewIfdIdentity(ifdTag IfdTag, parts ...IfdIdentityPart) (ii *IfdIdentity) {
	ii = &IfdIdentity{
		ifdTag: ifdTag,
		parts:  parts,
	}

	ii.ifdPath = ii.getIfdPath()
	ii.fqIfdPath = ii.getFqIfdPath()

	return ii
}

// NewIfdIdentityFromString parses a string like "IFD/Exif" or "IFD1" or
// something more exotic with custom IFDs ("SomeIFD4/SomeChildIFD6"). Note that
// this will valid the unindexed IFD structure (because the standard tags from
// the specification are unindexed), but not, obviously, any indices (e.g.
// the numbers in "IFD0", "IFD1", "SomeIFD4/SomeChildIFD6"). It is
// required for the caller to check whether these specific instances
// were actually parsed out of the stream.
func NewIfdIdentityFromString(im *IfdMapping, fqIfdPath string) (ii *IfdIdentity, err error) {
	defer func() {
		if state := recover(); state != nil {
			err = log.Wrap(state.(error))
		}
	}()

	lineage, err := im.ResolvePath(fqIfdPath)
	log.PanicIf(err)

	var lastIt *IfdTag
	identityParts := make([]IfdIdentityPart, len(lineage))
	for i, itii := range lineage {
		// Build out the tag that will eventually point to the IFD represented
		// by the right-most part in the IFD path.

		it := &IfdTag{
			parentIfdTag: lastIt,
			tagId:        itii.TagId,
			name:         itii.Name,
		}

		lastIt = it

		// Create the next IfdIdentity part.

		iip := IfdIdentityPart{
			Name:  itii.Name,
			Index: itii.Index,
		}

		identityParts[i] = iip
	}

	ii = NewIfdIdentity(*lastIt, identityParts...)
	return ii, nil
}

func (ii *IfdIdentity) getFqIfdPath() string {
	partPhrases := make([]string, len(ii.parts))
	for i, iip := range ii.parts {
		partPhrases[i] = iip.String()
	}

	return strings.Join(partPhrases, "/")
}

func (ii *IfdIdentity) getIfdPath() string {
	partPhrases := make([]string, len(ii.parts))
	for i, iip := range ii.parts {
		partPhrases[i] = iip.UnindexedString()
	}

	return strings.Join(partPhrases, "/")
}

// String returns a fully-qualified IFD path.
func (ii *IfdIdentity) String() string {
	return ii.fqIfdPath
}

// UnindexedString returns a non-fully-qualified IFD path.
func (ii *IfdIdentity) UnindexedString() string {
	return ii.ifdPath
}

// IfdTag returns the tag struct behind this IFD.
func (ii *IfdIdentity) IfdTag() IfdTag {
	return ii.ifdTag
}

// TagId returns the tag-ID of the IFD.
func (ii *IfdIdentity) TagId() uint16 {
	return ii.ifdTag.TagId()
}

// LeafPathPart returns the last right-most path-part, which represents the
// current IFD.
func (ii *IfdIdentity) LeafPathPart() IfdIdentityPart {
	return ii.parts[len(ii.parts)-1]
}

// Name returns the simple name of this IFD.
func (ii *IfdIdentity) Name() string {
	return ii.LeafPathPart().Name
}

// Index returns the index of this IFD (more then one IFD under a parent IFD
// will be numbered [0..n]).
func (ii *IfdIdentity) Index() int {
	return ii.LeafPathPart().Index
}

// Equals returns true if the two IfdIdentity instances are effectively
// identical.
//
// Since there's no way to get a specific fully-qualified IFD path without a
// certain slice of parts and all other fields are also derived from this,
// checking that the fully-qualified IFD path is equals is sufficient.
func (ii *IfdIdentity) Equals(ii2 *IfdIdentity) bool {
	return ii.String() == ii2.String()
}

// NewChild creates an IfdIdentity for an IFD that is a child of the current
// IFD.
func (ii *IfdIdentity) NewChild(childIfdTag IfdTag, index int) (iiChild *IfdIdentity) {
	if *childIfdTag.parentIfdTag != ii.ifdTag {
		log.Panicf("can not add child; we are not the parent:\nUS=%v\nCHILD=%v", ii.ifdTag, childIfdTag)
	}

	childPart := IfdIdentityPart{childIfdTag.name, index}
	childParts := append(ii.parts, childPart)

	iiChild = NewIfdIdentity(childIfdTag, childParts...)
	return iiChild
}

// NewSibling creates an IfdIdentity for an IFD that is a sibling to the current
// one.
func (ii *IfdIdentity) NewSibling(index int) (iiSibling *IfdIdentity) {
	parts := make([]IfdIdentityPart, len(ii.parts))

	copy(parts, ii.parts)
	parts[len(parts)-1].Index = index

	iiSibling = NewIfdIdentity(ii.ifdTag, parts...)
	return iiSibling
}

var (
	// IfdStandardIfdIdentity represents the IFD path for IFD0.
	IfdStandardIfdIdentity = NewIfdIdentity(rootStandardIfd, IfdIdentityPart{"IFD", 0})

	// IfdExifStandardIfdIdentity represents the IFD path for IFD0/Exif0.
	IfdExifStandardIfdIdentity = IfdStandardIfdIdentity.NewChild(exifStandardIfd, 0)

	// IfdExifIopStandardIfdIdentity represents the IFD path for IFD0/Exif0/Iop0.
	IfdExifIopStandardIfdIdentity = IfdExifStandardIfdIdentity.NewChild(iopStandardIfd, 0)

	// IfdGPSInfoStandardIfdIdentity represents the IFD path for IFD0/GPSInfo0.
	IfdGpsInfoStandardIfdIdentity = IfdStandardIfdIdentity.NewChild(gpsInfoStandardIfd, 0)

	// Ifd1StandardIfdIdentity represents the IFD path for IFD1.
	Ifd1StandardIfdIdentity = NewIfdIdentity(rootStandardIfd, IfdIdentityPart{"IFD", 1})
)

var (
	IfdPathStandard        = IfdStandardIfdIdentity
	IfdPathStandardExif    = IfdExifStandardIfdIdentity
	IfdPathStandardExifIop = IfdExifIopStandardIfdIdentity
	IfdPathStandardGps     = IfdGpsInfoStandardIfdIdentity
)