tiff

type BReader ¶

type BReader interface {
	BRead(data interface{}) error
	BReadSection(data interface{}, offset int64, n int64) error
	ByteOrder() binary.ByteOrder
	ReadAtReadSeeker
}

BReader wraps a ReadAtReadSeeker with a specific binary.ByteOrder.

func NewBReader(r ReadAtReadSeeker, o binary.ByteOrder) BReader

type Entry ¶

type Entry interface {
	TagID() uint16
	TypeID() uint16
	Count() uint32
	ValueOffset() [4]byte
}

Entry represents a single entry in an IFD in a TIFF file. This is the mostly uninterpreted core 12 byte data structure only.

func ParseEntry(br BReader) (out Entry, err error)

type ErrInvalidByteOrder ¶

type ErrInvalidByteOrder struct {
	Order [2]byte
}

func (e ErrInvalidByteOrder) Error() string

type ErrUnsuppConversion ¶

type ErrUnsuppConversion struct {
	From FieldType
	To   reflect.Type
}

func (e ErrUnsuppConversion) Error() string

type ErrUnsuppStructField ¶

type ErrUnsuppStructField struct {
	T       reflect.Type
	Field   int
	Problem string
}

func (e ErrUnsuppStructField) Error() string

type ErrUnsuppTIFFVersion ¶

type ErrUnsuppTIFFVersion struct {
	Version uint16
}

func (e ErrUnsuppTIFFVersion) Error() string

type Field ¶

type Field interface {
	Tag() Tag
	Type() FieldType
	Count() uint64
	Offset() uint64
	Value() FieldValue // TODO: Change to BReader??
}

Field represents a field in an IFD in a TIFF file.

func ParseField(br BReader, tsp TagSpace, ftsp FieldTypeSpace) (out Field, err error)

type FieldInterpreter ¶

type FieldInterpreter func(Field) string

type FieldParser ¶

type FieldParser func(BReader, TagSpace, FieldTypeSpace) (Field, error)

type FieldType ¶

type FieldType interface {
	ID() uint16
	Name() string
	Size() uint64
	Signed() bool
	ReflectType() reflect.Type
	Repr() FieldTypeRepr
	Valuer() FieldTypeValuer
}

A FieldType represents all of the necessary pieces of information one needs to know about a field type including a function that knows how to represent that type of data in an often human readable string. Other string representation formats could be implemented (json, xml, etc). Field types themselves have no actual stored value inside a TIFF. They are here to help an implementer or user understand their format.

func NewFieldType(id uint16, name string, size uint64, signed bool, repr FieldTypeRepr, rval FieldTypeValuer, typ reflect.Type) FieldType

type FieldTypeRepr ¶

type FieldTypeRepr func([]byte, binary.ByteOrder) string

type FieldTypeSet ¶

type FieldTypeSet interface {
	GetFieldType(id uint16) (FieldType, bool)
	ListFieldTypes() []uint16
	ListFieldTypeNames() []string
	Name() string
	Register(ft FieldType) bool
	Lock()
}

FieldTypeSet represents a set of field types that may be in use within a file that uses a TIFF file structure. This can be customized for custom file formats and private IFDs.

func NewFieldTypeSet(name string) FieldTypeSet

type FieldTypeSpace ¶

type FieldTypeSpace interface {
	Name() string
	GetFieldType(id uint16) FieldType
	GetFieldTypeSet(name string) (FieldTypeSet, bool)
	ListFieldTypeSets() []string
	RegisterFieldTypeSet(fts FieldTypeSet)
}

A FieldTypeSpace represents a group of FieldTypeSets where each of the FieldTypes from one FieldTypeSet should not collide with any of the FieldTypes from another FieldTypeSet.

func GetFieldTypeSpace(name string) FieldTypeSpace

func NewFieldTypeSpace(name string) FieldTypeSpace

type FieldTypeValuer ¶

type FieldTypeValuer func([]byte, binary.ByteOrder) reflect.Value

type FieldValue ¶

type FieldValue interface {
	Order() binary.ByteOrder
	Bytes() []byte
}

type Header ¶

type Header interface {
	Order() string
	Version() uint16
	OffsetSize() uint16
	FirstOffset() uint64
}

type IFD ¶

type IFD interface {
	NumEntries() uint64
	Fields() []Field
	NextOffset() uint64
	HasField(tagID uint16) bool
	GetField(tagID uint16) Field
}

IFD represents the data structure of an IFD in a TIFF File.

func ParseIFD(br BReader, offset uint64, tsp TagSpace, ftsp FieldTypeSpace) (out IFD, err error)

type IFDParser ¶

type IFDParser func(br BReader, offset uint64, tsp TagSpace, ftsp FieldTypeSpace) (IFD, error)

type ReadAtReadSeeker ¶

type ReadAtReadSeeker interface {
	io.ReadSeeker
	io.ReaderAt
}

ReadAtReadSeeker is the interface that wraps the Read, ReadAt, and Seek methods. Typical use cases would satisfy this with a bytes.Reader (in memory) or an os.File (on disk). For truly large files, such as BigTIFF, a user may want to create a custom solution that combines both in memory and on disk solutions for accessing the contents.

func NewReadAtReadSeeker(r io.Reader) ReadAtReadSeeker

type TIFF ¶

type TIFF interface {
	Header
	IFDs() []IFD
	R() BReader
}

func Parse(r ReadAtReadSeeker, tsp TagSpace, ftsp FieldTypeSpace) (TIFF, error)

func ParseTIFF(ordr [2]byte, vers uint16, br BReader, tsp TagSpace, ftsp FieldTypeSpace) (out TIFF, err error)

type TIFFParser ¶

type TIFFParser func(ordr [2]byte, vers uint16, br BReader, tsp TagSpace, ftsp FieldTypeSpace) (TIFF, error)

func GetVersionParser(v uint16) TIFFParser

type Tag ¶

type Tag interface {
	ID() uint16
	Name() string
	Interpreter() FieldInterpreter
}

func NewTag(id uint16, name string, fi FieldInterpreter) Tag

type TagSet ¶

type TagSet interface {
	GetTag(id uint16) (Tag, bool)
	ListTags() []uint16
	ListTagNames() []string
	Name() string
	Register(t Tag) bool
	Lock()
}

func NewTagSet(name string, lower, upper uint16) TagSet

type TagSpace ¶

type TagSpace interface {
	Name() string
	GetTag(id uint16) Tag
	GetTagSet(name string) (TagSet, bool)
	GetTagSetNameFromTag(id uint16) string
	ListTagSets() []string
	RegisterTagSet(ts TagSet)
}

A TagSpace represents a group of TagSet where each of the tags from one TagSet should not collide with any of the tags from another TagSet.

func GetTagSpace(name string) TagSpace

func NewTagSpace(name string) TagSpace