gtsocial-umbx

ifd_builder.go (29578B)

---

 package exif
 
 // NOTES:
 //
 // The thumbnail offset and length tags shouldn't be set directly. Use the
 // (*IfdBuilder).SetThumbnail() method instead.
 
 import (
 	"errors"
 	"fmt"
 	"strings"
 
 	"encoding/binary"
 
 	"github.com/dsoprea/go-logging"
 
 	"github.com/dsoprea/go-exif/v3/common"
 	"github.com/dsoprea/go-exif/v3/undefined"
 )
 
 var (
 	ifdBuilderLogger = log.NewLogger("exif.ifd_builder")
 )
 
 var (
 	ErrTagEntryNotFound = errors.New("tag entry not found")
 	ErrChildIbNotFound  = errors.New("child IB not found")
 )
 
 type IfdBuilderTagValue struct {
 	valueBytes []byte
 	ib         *IfdBuilder
 }
 
 func (ibtv IfdBuilderTagValue) String() string {
 	if ibtv.IsBytes() == true {
 		var valuePhrase string
 		if len(ibtv.valueBytes) <= 8 {
 			valuePhrase = fmt.Sprintf("%v", ibtv.valueBytes)
 		} else {
 			valuePhrase = fmt.Sprintf("%v...", ibtv.valueBytes[:8])
 		}
 
 		return fmt.Sprintf("IfdBuilderTagValue<BYTES=%v LEN=(%d)>", valuePhrase, len(ibtv.valueBytes))
 	} else if ibtv.IsIb() == true {
 		return fmt.Sprintf("IfdBuilderTagValue<IB=%s>", ibtv.ib)
 	} else {
 		log.Panicf("IBTV state undefined")
 		return ""
 	}
 }
 
 func NewIfdBuilderTagValueFromBytes(valueBytes []byte) *IfdBuilderTagValue {
 	return &IfdBuilderTagValue{
 		valueBytes: valueBytes,
 	}
 }
 
 func NewIfdBuilderTagValueFromIfdBuilder(ib *IfdBuilder) *IfdBuilderTagValue {
 	return &IfdBuilderTagValue{
 		ib: ib,
 	}
 }
 
 // IsBytes returns true if the bytes are populated. This is always the case
 // when we're loaded from a tag in an existing IFD.
 func (ibtv IfdBuilderTagValue) IsBytes() bool {
 	return ibtv.valueBytes != nil
 }
 
 func (ibtv IfdBuilderTagValue) Bytes() []byte {
 	if ibtv.IsBytes() == false {
 		log.Panicf("this tag is not a byte-slice value")
 	} else if ibtv.IsIb() == true {
 		log.Panicf("this tag is an IFD-builder value not a byte-slice")
 	}
 
 	return ibtv.valueBytes
 }
 
 func (ibtv IfdBuilderTagValue) IsIb() bool {
 	return ibtv.ib != nil
 }
 
 func (ibtv IfdBuilderTagValue) Ib() *IfdBuilder {
 	if ibtv.IsIb() == false {
 		log.Panicf("this tag is not an IFD-builder value")
 	} else if ibtv.IsBytes() == true {
 		log.Panicf("this tag is a byte-slice, not a IFD-builder")
 	}
 
 	return ibtv.ib
 }
 
 type BuilderTag struct {
 	// ifdPath is the path of the IFD that hosts this tag.
 	ifdPath string
 
 	tagId  uint16
 	typeId exifcommon.TagTypePrimitive
 
 	// value is either a value that can be encoded, an IfdBuilder instance (for
 	// child IFDs), or an IfdTagEntry instance representing an existing,
 	// previously-stored tag.
 	value *IfdBuilderTagValue
 
 	// byteOrder is the byte order. It's chiefly/originally here to support
 	// printing the value.
 	byteOrder binary.ByteOrder
 }
 
 func NewBuilderTag(ifdPath string, tagId uint16, typeId exifcommon.TagTypePrimitive, value *IfdBuilderTagValue, byteOrder binary.ByteOrder) *BuilderTag {
 	return &BuilderTag{
 		ifdPath:   ifdPath,
 		tagId:     tagId,
 		typeId:    typeId,
 		value:     value,
 		byteOrder: byteOrder,
 	}
 }
 
 func NewChildIfdBuilderTag(ifdPath string, tagId uint16, value *IfdBuilderTagValue) *BuilderTag {
 	return &BuilderTag{
 		ifdPath: ifdPath,
 		tagId:   tagId,
 		typeId:  exifcommon.TypeLong,
 		value:   value,
 	}
 }
 
 func (bt *BuilderTag) Value() (value *IfdBuilderTagValue) {
 	return bt.value
 }
 
 func (bt *BuilderTag) String() string {
 	var valueString string
 
 	if bt.value.IsBytes() == true {
 		var err error
 
 		valueString, err = exifcommon.FormatFromBytes(bt.value.Bytes(), bt.typeId, false, bt.byteOrder)
 		log.PanicIf(err)
 	} else {
 		valueString = fmt.Sprintf("%v", bt.value)
 	}
 
 	return fmt.Sprintf("BuilderTag<IFD-PATH=[%s] TAG-ID=(0x%04x) TAG-TYPE=[%s] VALUE=[%s]>", bt.ifdPath, bt.tagId, bt.typeId.String(), valueString)
 }
 
 func (bt *BuilderTag) SetValue(byteOrder binary.ByteOrder, value interface{}) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	// TODO(dustin): !! Add test.
 
 	var ed exifcommon.EncodedData
 	if bt.typeId == exifcommon.TypeUndefined {
 		encodeable := value.(exifundefined.EncodeableValue)
 
 		encoded, unitCount, err := exifundefined.Encode(encodeable, byteOrder)
 		log.PanicIf(err)
 
 		ed = exifcommon.EncodedData{
 			Type:      exifcommon.TypeUndefined,
 			Encoded:   encoded,
 			UnitCount: unitCount,
 		}
 	} else {
 		ve := exifcommon.NewValueEncoder(byteOrder)
 
 		var err error
 
 		ed, err = ve.Encode(value)
 		log.PanicIf(err)
 	}
 
 	bt.value = NewIfdBuilderTagValueFromBytes(ed.Encoded)
 
 	return nil
 }
 
 // NewStandardBuilderTag constructs a `BuilderTag` instance. The type is looked
 // up. `ii` is the type of IFD that owns this tag.
 func NewStandardBuilderTag(ifdPath string, it *IndexedTag, byteOrder binary.ByteOrder, value interface{}) *BuilderTag {
 	// If there is more than one supported type, we'll go with the larger to
 	// encode with. It'll use the same amount of fixed-space, and we'll
 	// eliminate unnecessary overflows/issues.
 	tagType := it.GetEncodingType(value)
 
 	var rawBytes []byte
 	if it.DoesSupportType(exifcommon.TypeUndefined) == true {
 		encodeable := value.(exifundefined.EncodeableValue)
 
 		var err error
 
 		rawBytes, _, err = exifundefined.Encode(encodeable, byteOrder)
 		log.PanicIf(err)
 	} else {
 		ve := exifcommon.NewValueEncoder(byteOrder)
 
 		ed, err := ve.Encode(value)
 		log.PanicIf(err)
 
 		rawBytes = ed.Encoded
 	}
 
 	tagValue := NewIfdBuilderTagValueFromBytes(rawBytes)
 
 	return NewBuilderTag(
 		ifdPath,
 		it.Id,
 		tagType,
 		tagValue,
 		byteOrder)
 }
 
 type IfdBuilder struct {
 	ifdIdentity *exifcommon.IfdIdentity
 
 	byteOrder binary.ByteOrder
 
 	// Includes both normal tags and IFD tags (which point to child IFDs).
 	// TODO(dustin): Keep a separate list of children like with `Ifd`.
 	// TODO(dustin): Either rename this or `Entries` in `Ifd` to be the same thing.
 	tags []*BuilderTag
 
 	// existingOffset will be the offset that this IFD is currently found at if
 	// it represents an IFD that has previously been stored (or 0 if not).
 	existingOffset uint32
 
 	// nextIb represents the next link if we're chaining to another.
 	nextIb *IfdBuilder
 
 	// thumbnailData is populated with thumbnail data if there was thumbnail
 	// data. Otherwise, it's nil.
 	thumbnailData []byte
 
 	ifdMapping *exifcommon.IfdMapping
 	tagIndex   *TagIndex
 }
 
 func NewIfdBuilder(ifdMapping *exifcommon.IfdMapping, tagIndex *TagIndex, ii *exifcommon.IfdIdentity, byteOrder binary.ByteOrder) (ib *IfdBuilder) {
 	ib = &IfdBuilder{
 		ifdIdentity: ii,
 
 		byteOrder: byteOrder,
 		tags:      make([]*BuilderTag, 0),
 
 		ifdMapping: ifdMapping,
 		tagIndex:   tagIndex,
 	}
 
 	return ib
 }
 
 // NewIfdBuilderWithExistingIfd creates a new IB using the same header type
 // information as the given IFD.
 func NewIfdBuilderWithExistingIfd(ifd *Ifd) (ib *IfdBuilder) {
 	ib = &IfdBuilder{
 		ifdIdentity: ifd.IfdIdentity(),
 
 		byteOrder:      ifd.ByteOrder(),
 		existingOffset: ifd.Offset(),
 		ifdMapping:     ifd.ifdMapping,
 		tagIndex:       ifd.tagIndex,
 	}
 
 	return ib
 }
 
 // NewIfdBuilderFromExistingChain creates a chain of IB instances from an
 // IFD chain generated from real data.
 func NewIfdBuilderFromExistingChain(rootIfd *Ifd) (firstIb *IfdBuilder) {
 	var lastIb *IfdBuilder
 	i := 0
 	for thisExistingIfd := rootIfd; thisExistingIfd != nil; thisExistingIfd = thisExistingIfd.nextIfd {
 		newIb := NewIfdBuilder(
 			rootIfd.ifdMapping,
 			rootIfd.tagIndex,
 			rootIfd.ifdIdentity,
 			thisExistingIfd.ByteOrder())
 
 		if firstIb == nil {
 			firstIb = newIb
 		} else {
 			lastIb.SetNextIb(newIb)
 		}
 
 		err := newIb.AddTagsFromExisting(thisExistingIfd, nil, nil)
 		log.PanicIf(err)
 
 		lastIb = newIb
 		i++
 	}
 
 	return firstIb
 }
 
 func (ib *IfdBuilder) IfdIdentity() *exifcommon.IfdIdentity {
 	return ib.ifdIdentity
 }
 
 func (ib *IfdBuilder) NextIb() (nextIb *IfdBuilder, err error) {
 	return ib.nextIb, nil
 }
 
 func (ib *IfdBuilder) ChildWithTagId(childIfdTagId uint16) (childIb *IfdBuilder, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	for _, bt := range ib.tags {
 		if bt.value.IsIb() == false {
 			continue
 		}
 
 		childIbThis := bt.value.Ib()
 
 		if childIbThis.IfdIdentity().TagId() == childIfdTagId {
 			return childIbThis, nil
 		}
 	}
 
 	log.Panic(ErrChildIbNotFound)
 
 	// Never reached.
 	return nil, nil
 }
 
 func getOrCreateIbFromRootIbInner(rootIb *IfdBuilder, parentIb *IfdBuilder, currentLineage []exifcommon.IfdTagIdAndIndex) (ib *IfdBuilder, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	// TODO(dustin): !! Add test.
 
 	thisIb := rootIb
 
 	// Since we're calling ourselves recursively with incrementally different
 	// paths, the FQ IFD-path of the parent that called us needs to be passed
 	// in, in order for us to know it.
 	var parentLineage []exifcommon.IfdTagIdAndIndex
 	if parentIb != nil {
 		var err error
 
 		parentLineage, err = thisIb.ifdMapping.ResolvePath(parentIb.IfdIdentity().String())
 		log.PanicIf(err)
 	}
 
 	// Process the current path part.
 	currentItIi := currentLineage[0]
 
 	// Make sure the leftmost part of the FQ IFD-path agrees with the IB we
 	// were given.
 
 	expectedFqRootIfdPath := ""
 	if parentLineage != nil {
 		expectedLineage := append(parentLineage, currentItIi)
 		expectedFqRootIfdPath = thisIb.ifdMapping.PathPhraseFromLineage(expectedLineage)
 	} else {
 		expectedFqRootIfdPath = thisIb.ifdMapping.PathPhraseFromLineage(currentLineage[:1])
 	}
 
 	if expectedFqRootIfdPath != thisIb.IfdIdentity().String() {
 		log.Panicf("the FQ IFD-path [%s] we were given does not match the builder's FQ IFD-path [%s]", expectedFqRootIfdPath, thisIb.IfdIdentity().String())
 	}
 
 	// If we actually wanted a sibling (currentItIi.Index > 0) then seek to it,
 	// appending new siblings, as required, until we get there.
 	for i := 0; i < currentItIi.Index; i++ {
 		if thisIb.nextIb == nil {
 			// Generate an FQ IFD-path for the sibling. It'll use the same
 			// non-FQ IFD-path as the current IB.
 
 			iiSibling := thisIb.IfdIdentity().NewSibling(i + 1)
 			thisIb.nextIb = NewIfdBuilder(thisIb.ifdMapping, thisIb.tagIndex, iiSibling, thisIb.byteOrder)
 		}
 
 		thisIb = thisIb.nextIb
 	}
 
 	// There is no child IFD to process. We're done.
 	if len(currentLineage) == 1 {
 		return thisIb, nil
 	}
 
 	// Establish the next child to be processed.
 
 	childItii := currentLineage[1]
 
 	var foundChild *IfdBuilder
 	for _, bt := range thisIb.tags {
 		if bt.value.IsIb() == false {
 			continue
 		}
 
 		childIb := bt.value.Ib()
 
 		if childIb.IfdIdentity().TagId() == childItii.TagId {
 			foundChild = childIb
 			break
 		}
 	}
 
 	// If we didn't find the child, add it.
 
 	if foundChild == nil {
 		currentIfdTag := thisIb.IfdIdentity().IfdTag()
 
 		childIfdTag :=
 			exifcommon.NewIfdTag(
 				&currentIfdTag,
 				childItii.TagId,
 				childItii.Name)
 
 		iiChild := thisIb.IfdIdentity().NewChild(childIfdTag, 0)
 
 		foundChild =
 			NewIfdBuilder(
 				thisIb.ifdMapping,
 				thisIb.tagIndex,
 				iiChild,
 				thisIb.byteOrder)
 
 		err = thisIb.AddChildIb(foundChild)
 		log.PanicIf(err)
 	}
 
 	finalIb, err := getOrCreateIbFromRootIbInner(foundChild, thisIb, currentLineage[1:])
 	log.PanicIf(err)
 
 	return finalIb, nil
 }
 
 // GetOrCreateIbFromRootIb returns an IB representing the requested IFD, even if
 // an IB doesn't already exist for it. This function may call itself
 // recursively.
 func GetOrCreateIbFromRootIb(rootIb *IfdBuilder, fqIfdPath string) (ib *IfdBuilder, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	// lineage is a necessity of our recursion process. It doesn't include any
 	// parent IFDs on its left-side; it starts with the current IB only.
 	lineage, err := rootIb.ifdMapping.ResolvePath(fqIfdPath)
 	log.PanicIf(err)
 
 	ib, err = getOrCreateIbFromRootIbInner(rootIb, nil, lineage)
 	log.PanicIf(err)
 
 	return ib, nil
 }
 
 func (ib *IfdBuilder) String() string {
 	nextIfdPhrase := ""
 	if ib.nextIb != nil {
 		// TODO(dustin): We were setting this to ii.String(), but we were getting hex-data when printing this after building from an existing chain.
 		nextIfdPhrase = ib.nextIb.IfdIdentity().UnindexedString()
 	}
 
 	return fmt.Sprintf("IfdBuilder<PATH=[%s] TAG-ID=(0x%04x) COUNT=(%d) OFF=(0x%04x) NEXT-IFD-PATH=[%s]>", ib.IfdIdentity().UnindexedString(), ib.IfdIdentity().TagId(), len(ib.tags), ib.existingOffset, nextIfdPhrase)
 }
 
 func (ib *IfdBuilder) Tags() (tags []*BuilderTag) {
 	return ib.tags
 }
 
 // SetThumbnail sets thumbnail data.
 //
 // NOTES:
 //
 // - We don't manage any facet of the thumbnail data. This is the
 //   responsibility of the user/developer.
 // - This method will fail unless the thumbnail is set on a the root IFD.
 //   However, in order to be valid, it must be set on the second one, linked to
 //   by the first, as per the EXIF/TIFF specification.
 // - We set the offset to (0) now but will allocate the data and properly assign
 //   the offset when the IB is encoded (later).
 func (ib *IfdBuilder) SetThumbnail(data []byte) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	if ib.IfdIdentity().UnindexedString() != exifcommon.IfdStandardIfdIdentity.UnindexedString() {
 		log.Panicf("thumbnails can only go into a root Ifd (and only the second one)")
 	}
 
 	// TODO(dustin): !! Add a test for this function.
 
 	if data == nil || len(data) == 0 {
 		log.Panic("thumbnail is empty")
 	}
 
 	ib.thumbnailData = data
 
 	ibtvfb := NewIfdBuilderTagValueFromBytes(ib.thumbnailData)
 	offsetBt :=
 		NewBuilderTag(
 			ib.IfdIdentity().UnindexedString(),
 			ThumbnailOffsetTagId,
 			exifcommon.TypeLong,
 			ibtvfb,
 			ib.byteOrder)
 
 	err = ib.Set(offsetBt)
 	log.PanicIf(err)
 
 	thumbnailSizeIt, err := ib.tagIndex.Get(ib.IfdIdentity(), ThumbnailSizeTagId)
 	log.PanicIf(err)
 
 	sizeBt := NewStandardBuilderTag(ib.IfdIdentity().UnindexedString(), thumbnailSizeIt, ib.byteOrder, []uint32{uint32(len(ib.thumbnailData))})
 
 	err = ib.Set(sizeBt)
 	log.PanicIf(err)
 
 	return nil
 }
 
 func (ib *IfdBuilder) Thumbnail() []byte {
 	return ib.thumbnailData
 }
 
 func (ib *IfdBuilder) printTagTree(levels int) {
 	indent := strings.Repeat(" ", levels*2)
 
 	i := 0
 	for currentIb := ib; currentIb != nil; currentIb = currentIb.nextIb {
 		prefix := " "
 		if i > 0 {
 			prefix = ">"
 		}
 
 		if levels == 0 {
 			fmt.Printf("%s%sIFD: %s INDEX=(%d)\n", indent, prefix, currentIb, i)
 		} else {
 			fmt.Printf("%s%sChild IFD: %s\n", indent, prefix, currentIb)
 		}
 
 		if len(currentIb.tags) > 0 {
 			fmt.Printf("\n")
 
 			for i, tag := range currentIb.tags {
 				isChildIb := false
 				_, err := ib.ifdMapping.GetChild(currentIb.IfdIdentity().UnindexedString(), tag.tagId)
 				if err == nil {
 					isChildIb = true
 				} else if log.Is(err, exifcommon.ErrChildIfdNotMapped) == false {
 					log.Panic(err)
 				}
 
 				tagName := ""
 
 				// If a normal tag (not a child IFD) get the name.
 				if isChildIb == true {
 					tagName = "<Child IFD>"
 				} else {
 					it, err := ib.tagIndex.Get(ib.ifdIdentity, tag.tagId)
 					if log.Is(err, ErrTagNotFound) == true {
 						tagName = "<UNKNOWN>"
 					} else if err != nil {
 						log.Panic(err)
 					} else {
 						tagName = it.Name
 					}
 				}
 
 				value := tag.Value()
 
 				if value.IsIb() == true {
 					fmt.Printf("%s  (%d): [%s] %s\n", indent, i, tagName, value.Ib())
 				} else {
 					fmt.Printf("%s  (%d): [%s] %s\n", indent, i, tagName, tag)
 				}
 
 				if isChildIb == true {
 					if tag.value.IsIb() == false {
 						log.Panicf("tag-ID (0x%04x) is an IFD but the tag value is not an IB instance: %v", tag.tagId, tag)
 					}
 
 					fmt.Printf("\n")
 
 					childIb := tag.value.Ib()
 					childIb.printTagTree(levels + 1)
 				}
 			}
 
 			fmt.Printf("\n")
 		}
 
 		i++
 	}
 }
 
 func (ib *IfdBuilder) PrintTagTree() {
 	ib.printTagTree(0)
 }
 
 func (ib *IfdBuilder) printIfdTree(levels int) {
 	indent := strings.Repeat(" ", levels*2)
 
 	i := 0
 	for currentIb := ib; currentIb != nil; currentIb = currentIb.nextIb {
 		prefix := " "
 		if i > 0 {
 			prefix = ">"
 		}
 
 		fmt.Printf("%s%s%s\n", indent, prefix, currentIb)
 
 		if len(currentIb.tags) > 0 {
 			for _, tag := range currentIb.tags {
 				isChildIb := false
 				_, err := ib.ifdMapping.GetChild(currentIb.IfdIdentity().UnindexedString(), tag.tagId)
 				if err == nil {
 					isChildIb = true
 				} else if log.Is(err, exifcommon.ErrChildIfdNotMapped) == false {
 					log.Panic(err)
 				}
 
 				if isChildIb == true {
 					if tag.value.IsIb() == false {
 						log.Panicf("tag-ID (0x%04x) is an IFD but the tag value is not an IB instance: %v", tag.tagId, tag)
 					}
 
 					childIb := tag.value.Ib()
 					childIb.printIfdTree(levels + 1)
 				}
 			}
 		}
 
 		i++
 	}
 }
 
 func (ib *IfdBuilder) PrintIfdTree() {
 	ib.printIfdTree(0)
 }
 
 func (ib *IfdBuilder) dumpToStrings(thisIb *IfdBuilder, prefix string, tagId uint16, lines []string) (linesOutput []string) {
 	if lines == nil {
 		linesOutput = make([]string, 0)
 	} else {
 		linesOutput = lines
 	}
 
 	siblingIfdIndex := 0
 	for ; thisIb != nil; thisIb = thisIb.nextIb {
 		line := fmt.Sprintf("IFD<PARENTS=[%s] FQ-IFD-PATH=[%s] IFD-INDEX=(%d) IFD-TAG-ID=(0x%04x) TAG=[0x%04x]>", prefix, thisIb.IfdIdentity().String(), siblingIfdIndex, thisIb.IfdIdentity().TagId(), tagId)
 		linesOutput = append(linesOutput, line)
 
 		for i, tag := range thisIb.tags {
 			var childIb *IfdBuilder
 			childIfdName := ""
 			if tag.value.IsIb() == true {
 				childIb = tag.value.Ib()
 				childIfdName = childIb.IfdIdentity().UnindexedString()
 			}
 
 			line := fmt.Sprintf("TAG<PARENTS=[%s] FQ-IFD-PATH=[%s] IFD-TAG-ID=(0x%04x) CHILD-IFD=[%s] TAG-INDEX=(%d) TAG=[0x%04x]>", prefix, thisIb.IfdIdentity().String(), thisIb.IfdIdentity().TagId(), childIfdName, i, tag.tagId)
 			linesOutput = append(linesOutput, line)
 
 			if childIb == nil {
 				continue
 			}
 
 			childPrefix := ""
 			if prefix == "" {
 				childPrefix = fmt.Sprintf("%s", thisIb.IfdIdentity().UnindexedString())
 			} else {
 				childPrefix = fmt.Sprintf("%s->%s", prefix, thisIb.IfdIdentity().UnindexedString())
 			}
 
 			linesOutput = thisIb.dumpToStrings(childIb, childPrefix, tag.tagId, linesOutput)
 		}
 
 		siblingIfdIndex++
 	}
 
 	return linesOutput
 }
 
 func (ib *IfdBuilder) DumpToStrings() (lines []string) {
 	return ib.dumpToStrings(ib, "", 0, lines)
 }
 
 func (ib *IfdBuilder) SetNextIb(nextIb *IfdBuilder) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	ib.nextIb = nextIb
 
 	return nil
 }
 
 func (ib *IfdBuilder) DeleteN(tagId uint16, n int) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	if n < 1 {
 		log.Panicf("N must be at least 1: (%d)", n)
 	}
 
 	for n > 0 {
 		j := -1
 		for i, bt := range ib.tags {
 			if bt.tagId == tagId {
 				j = i
 				break
 			}
 		}
 
 		if j == -1 {
 			log.Panic(ErrTagEntryNotFound)
 		}
 
 		ib.tags = append(ib.tags[:j], ib.tags[j+1:]...)
 		n--
 	}
 
 	return nil
 }
 
 func (ib *IfdBuilder) DeleteFirst(tagId uint16) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	err = ib.DeleteN(tagId, 1)
 	log.PanicIf(err)
 
 	return nil
 }
 
 func (ib *IfdBuilder) DeleteAll(tagId uint16) (n int, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	for {
 		err = ib.DeleteN(tagId, 1)
 		if log.Is(err, ErrTagEntryNotFound) == true {
 			break
 		} else if err != nil {
 			log.Panic(err)
 		}
 
 		n++
 	}
 
 	return n, nil
 }
 
 func (ib *IfdBuilder) ReplaceAt(position int, bt *BuilderTag) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	if position < 0 {
 		log.Panicf("replacement position must be 0 or greater")
 	} else if position >= len(ib.tags) {
 		log.Panicf("replacement position does not exist")
 	}
 
 	ib.tags[position] = bt
 
 	return nil
 }
 
 func (ib *IfdBuilder) Replace(tagId uint16, bt *BuilderTag) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	position, err := ib.Find(tagId)
 	log.PanicIf(err)
 
 	ib.tags[position] = bt
 
 	return nil
 }
 
 // Set will add a new entry or update an existing entry.
 func (ib *IfdBuilder) Set(bt *BuilderTag) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	position, err := ib.Find(bt.tagId)
 	if err == nil {
 		ib.tags[position] = bt
 	} else if log.Is(err, ErrTagEntryNotFound) == true {
 		err = ib.add(bt)
 		log.PanicIf(err)
 	} else {
 		log.Panic(err)
 	}
 
 	return nil
 }
 
 func (ib *IfdBuilder) FindN(tagId uint16, maxFound int) (found []int, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	found = make([]int, 0)
 
 	for i, bt := range ib.tags {
 		if bt.tagId == tagId {
 			found = append(found, i)
 			if maxFound == 0 || len(found) >= maxFound {
 				break
 			}
 		}
 	}
 
 	return found, nil
 }
 
 func (ib *IfdBuilder) Find(tagId uint16) (position int, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	found, err := ib.FindN(tagId, 1)
 	log.PanicIf(err)
 
 	if len(found) == 0 {
 		log.Panic(ErrTagEntryNotFound)
 	}
 
 	return found[0], nil
 }
 
 func (ib *IfdBuilder) FindTag(tagId uint16) (bt *BuilderTag, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	found, err := ib.FindN(tagId, 1)
 	log.PanicIf(err)
 
 	if len(found) == 0 {
 		log.Panic(ErrTagEntryNotFound)
 	}
 
 	position := found[0]
 
 	return ib.tags[position], nil
 }
 
 func (ib *IfdBuilder) FindTagWithName(tagName string) (bt *BuilderTag, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	it, err := ib.tagIndex.GetWithName(ib.IfdIdentity(), tagName)
 	log.PanicIf(err)
 
 	found, err := ib.FindN(it.Id, 1)
 	log.PanicIf(err)
 
 	if len(found) == 0 {
 		log.Panic(ErrTagEntryNotFound)
 	}
 
 	position := found[0]
 
 	return ib.tags[position], nil
 }
 
 func (ib *IfdBuilder) add(bt *BuilderTag) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	if bt.ifdPath == "" {
 		log.Panicf("BuilderTag ifdPath is not set: %s", bt)
 	} else if bt.typeId == 0x0 {
 		log.Panicf("BuilderTag type-ID is not set: %s", bt)
 	} else if bt.value == nil {
 		log.Panicf("BuilderTag value is not set: %s", bt)
 	}
 
 	ib.tags = append(ib.tags, bt)
 	return nil
 }
 
 func (ib *IfdBuilder) Add(bt *BuilderTag) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	if bt.value.IsIb() == true {
 		log.Panicf("child IfdBuilders must be added via AddChildIb() or AddTagsFromExisting(), not Add()")
 	}
 
 	err = ib.add(bt)
 	log.PanicIf(err)
 
 	return nil
 }
 
 // AddChildIb adds a tag that branches to a new IFD.
 func (ib *IfdBuilder) AddChildIb(childIb *IfdBuilder) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	if childIb.IfdIdentity().TagId() == 0 {
 		log.Panicf("IFD can not be used as a child IFD (not associated with a tag-ID): %v", childIb)
 	} else if childIb.byteOrder != ib.byteOrder {
 		log.Panicf("Child IFD does not have the same byte-order: [%s] != [%s]", childIb.byteOrder, ib.byteOrder)
 	}
 
 	// Since no standard IFDs supports occur`ring more than once, check that a
 	// tag of this type has not been previously added. Note that we just search
 	// the current IFD and *not every* IFD.
 	for _, bt := range childIb.tags {
 		if bt.tagId == childIb.IfdIdentity().TagId() {
 			log.Panicf("child-IFD already added: %v", childIb.IfdIdentity().UnindexedString())
 		}
 	}
 
 	bt := ib.NewBuilderTagFromBuilder(childIb)
 	ib.tags = append(ib.tags, bt)
 
 	return nil
 }
 
 func (ib *IfdBuilder) NewBuilderTagFromBuilder(childIb *IfdBuilder) (bt *BuilderTag) {
 	defer func() {
 		if state := recover(); state != nil {
 			err := log.Wrap(state.(error))
 			log.Panic(err)
 		}
 	}()
 
 	value := NewIfdBuilderTagValueFromIfdBuilder(childIb)
 
 	bt = NewChildIfdBuilderTag(
 		ib.IfdIdentity().UnindexedString(),
 		childIb.IfdIdentity().TagId(),
 		value)
 
 	return bt
 }
 
 // AddTagsFromExisting does a verbatim copy of the entries in `ifd` to this
 // builder. It excludes child IFDs. These must be added explicitly via
 // `AddChildIb()`.
 func (ib *IfdBuilder) AddTagsFromExisting(ifd *Ifd, includeTagIds []uint16, excludeTagIds []uint16) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	thumbnailData, err := ifd.Thumbnail()
 	if err == nil {
 		err = ib.SetThumbnail(thumbnailData)
 		log.PanicIf(err)
 	} else if log.Is(err, ErrNoThumbnail) == false {
 		log.Panic(err)
 	}
 
 	for i, ite := range ifd.Entries() {
 		if ite.IsThumbnailOffset() == true || ite.IsThumbnailSize() {
 			// These will be added on-the-fly when we encode.
 			continue
 		}
 
 		if excludeTagIds != nil && len(excludeTagIds) > 0 {
 			found := false
 			for _, excludedTagId := range excludeTagIds {
 				if excludedTagId == ite.TagId() {
 					found = true
 				}
 			}
 
 			if found == true {
 				continue
 			}
 		}
 
 		if includeTagIds != nil && len(includeTagIds) > 0 {
 			// Whether or not there was a list of excludes, if there is a list
 			// of includes than the current tag has to be in it.
 
 			found := false
 			for _, includedTagId := range includeTagIds {
 				if includedTagId == ite.TagId() {
 					found = true
 					break
 				}
 			}
 
 			if found == false {
 				continue
 			}
 		}
 
 		var bt *BuilderTag
 
 		if ite.ChildIfdPath() != "" {
 			// If we want to add an IFD tag, we'll have to build it first and
 			// *then* add it via a different method.
 
 			// Figure out which of the child-IFDs that are associated with
 			// this IFD represents this specific child IFD.
 
 			var childIfd *Ifd
 			for _, thisChildIfd := range ifd.Children() {
 				if thisChildIfd.ParentTagIndex() != i {
 					continue
 				} else if thisChildIfd.ifdIdentity.TagId() != 0xffff && thisChildIfd.ifdIdentity.TagId() != ite.TagId() {
 					log.Panicf("child-IFD tag is not correct: TAG-POSITION=(%d) ITE=%s CHILD-IFD=%s", thisChildIfd.ParentTagIndex(), ite, thisChildIfd)
 				}
 
 				childIfd = thisChildIfd
 				break
 			}
 
 			if childIfd == nil {
 				childTagIds := make([]string, len(ifd.Children()))
 				for j, childIfd := range ifd.Children() {
 					childTagIds[j] = fmt.Sprintf("0x%04x (parent tag-position %d)", childIfd.ifdIdentity.TagId(), childIfd.ParentTagIndex())
 				}
 
 				log.Panicf("could not find child IFD for child ITE: IFD-PATH=[%s] TAG-ID=(0x%04x) CURRENT-TAG-POSITION=(%d) CHILDREN=%v", ite.IfdPath(), ite.TagId(), i, childTagIds)
 			}
 
 			childIb := NewIfdBuilderFromExistingChain(childIfd)
 			bt = ib.NewBuilderTagFromBuilder(childIb)
 		} else {
 			// Non-IFD tag.
 
 			rawBytes, err := ite.GetRawBytes()
 			log.PanicIf(err)
 
 			value := NewIfdBuilderTagValueFromBytes(rawBytes)
 
 			bt = NewBuilderTag(
 				ifd.ifdIdentity.UnindexedString(),
 				ite.TagId(),
 				ite.TagType(),
 				value,
 				ib.byteOrder)
 		}
 
 		err := ib.add(bt)
 		log.PanicIf(err)
 	}
 
 	return nil
 }
 
 // AddStandard quickly and easily composes and adds the tag using the
 // information already known about a tag. Only works with standard tags.
 func (ib *IfdBuilder) AddStandard(tagId uint16, value interface{}) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	it, err := ib.tagIndex.Get(ib.IfdIdentity(), tagId)
 	log.PanicIf(err)
 
 	bt := NewStandardBuilderTag(ib.IfdIdentity().UnindexedString(), it, ib.byteOrder, value)
 
 	err = ib.add(bt)
 	log.PanicIf(err)
 
 	return nil
 }
 
 // AddStandardWithName quickly and easily composes and adds the tag using the
 // information already known about a tag (using the name). Only works with
 // standard tags.
 func (ib *IfdBuilder) AddStandardWithName(tagName string, value interface{}) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	it, err := ib.tagIndex.GetWithName(ib.IfdIdentity(), tagName)
 	log.PanicIf(err)
 
 	bt := NewStandardBuilderTag(ib.IfdIdentity().UnindexedString(), it, ib.byteOrder, value)
 
 	err = ib.add(bt)
 	log.PanicIf(err)
 
 	return nil
 }
 
 // SetStandard quickly and easily composes and adds or replaces the tag using
 // the information already known about a tag. Only works with standard tags.
 func (ib *IfdBuilder) SetStandard(tagId uint16, value interface{}) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	// TODO(dustin): !! Add test for this function.
 
 	it, err := ib.tagIndex.Get(ib.IfdIdentity(), tagId)
 	log.PanicIf(err)
 
 	bt := NewStandardBuilderTag(ib.IfdIdentity().UnindexedString(), it, ib.byteOrder, value)
 
 	i, err := ib.Find(tagId)
 	if err != nil {
 		if log.Is(err, ErrTagEntryNotFound) == false {
 			log.Panic(err)
 		}
 
 		ib.tags = append(ib.tags, bt)
 	} else {
 		ib.tags[i] = bt
 	}
 
 	return nil
 }
 
 // SetStandardWithName quickly and easily composes and adds or replaces the
 // tag using the information already known about a tag (using the name). Only
 // works with standard tags.
 func (ib *IfdBuilder) SetStandardWithName(tagName string, value interface{}) (err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	// TODO(dustin): !! Add test for this function.
 
 	it, err := ib.tagIndex.GetWithName(ib.IfdIdentity(), tagName)
 	log.PanicIf(err)
 
 	bt := NewStandardBuilderTag(ib.IfdIdentity().UnindexedString(), it, ib.byteOrder, value)
 
 	i, err := ib.Find(bt.tagId)
 	if err != nil {
 		if log.Is(err, ErrTagEntryNotFound) == false {
 			log.Panic(err)
 		}
 
 		ib.tags = append(ib.tags, bt)
 	} else {
 		ib.tags[i] = bt
 	}
 
 	return nil
 }