gotosocial/vendor/github.com/dsoprea/go-jpeg-image-structure/segment_list.go
Tobi Smethurst 98263a7de6
Grand test fixup (#138)
* start fixing up tests

* fix up tests + automate with drone

* fiddle with linting

* messing about with drone.yml

* some more fiddling

* hmmm

* add cache

* add vendor directory

* verbose

* ci updates

* update some little things

* update sig
2021-08-12 21:03:24 +02:00

396 lines
8.3 KiB
Go

package jpegstructure
import (
"bytes"
"fmt"
"io"
"crypto/sha1"
"encoding/binary"
"github.com/dsoprea/go-exif/v2"
"github.com/dsoprea/go-iptc"
"github.com/dsoprea/go-logging"
)
// SegmentList contains a slice of segments.
type SegmentList struct {
segments []*Segment
}
// NewSegmentList returns a new SegmentList struct.
func NewSegmentList(segments []*Segment) (sl *SegmentList) {
if segments == nil {
segments = make([]*Segment, 0)
}
return &SegmentList{
segments: segments,
}
}
// OffsetsEqual returns true is all segments have the same marker-IDs and were
// found at the same offsets.
func (sl *SegmentList) OffsetsEqual(o *SegmentList) bool {
if len(o.segments) != len(sl.segments) {
return false
}
for i, s := range o.segments {
if s.MarkerId != sl.segments[i].MarkerId || s.Offset != sl.segments[i].Offset {
return false
}
}
return true
}
// Segments returns the underlying slice of segments.
func (sl *SegmentList) Segments() []*Segment {
return sl.segments
}
// Add adds another segment.
func (sl *SegmentList) Add(s *Segment) {
sl.segments = append(sl.segments, s)
}
// Print prints segment info.
func (sl *SegmentList) Print() {
if len(sl.segments) == 0 {
fmt.Printf("No segments.\n")
} else {
exifIndex, _, err := sl.FindExif()
if err != nil {
if err == exif.ErrNoExif {
exifIndex = -1
} else {
log.Panic(err)
}
}
xmpIndex, _, err := sl.FindXmp()
if err != nil {
if err == ErrNoXmp {
xmpIndex = -1
} else {
log.Panic(err)
}
}
iptcIndex, _, err := sl.FindIptc()
if err != nil {
if err == ErrNoIptc {
iptcIndex = -1
} else {
log.Panic(err)
}
}
for i, s := range sl.segments {
fmt.Printf("%2d: %s", i, s.EmbeddedString())
if i == exifIndex {
fmt.Printf(" [EXIF]")
} else if i == xmpIndex {
fmt.Printf(" [XMP]")
} else if i == iptcIndex {
fmt.Printf(" [IPTC]")
}
fmt.Printf("\n")
}
}
}
// Validate checks that all of the markers are actually located at all of the
// recorded offsets.
func (sl *SegmentList) Validate(data []byte) (err error) {
defer func() {
if state := recover(); state != nil {
err = log.Wrap(state.(error))
}
}()
if len(sl.segments) < 2 {
log.Panicf("minimum segments not found")
}
if sl.segments[0].MarkerId != MARKER_SOI {
log.Panicf("first segment not SOI")
} else if sl.segments[len(sl.segments)-1].MarkerId != MARKER_EOI {
log.Panicf("last segment not EOI")
}
lastOffset := 0
for i, s := range sl.segments {
if lastOffset != 0 && s.Offset <= lastOffset {
log.Panicf("segment offset not greater than the last: SEGMENT=(%d) (0x%08x) <= (0x%08x)", i, s.Offset, lastOffset)
}
// The scan-data doesn't start with a marker.
if s.MarkerId == 0x0 {
continue
}
o := s.Offset
if bytes.Compare(data[o:o+2], []byte{0xff, s.MarkerId}) != 0 {
log.Panicf("segment offset does not point to the start of a segment: SEGMENT=(%d) (0x%08x)", i, s.Offset)
}
lastOffset = o
}
return nil
}
// FindExif returns the the segment that hosts the EXIF data (if present).
func (sl *SegmentList) FindExif() (index int, segment *Segment, err error) {
defer func() {
if state := recover(); state != nil {
err = log.Wrap(state.(error))
}
}()
for i, s := range sl.segments {
if s.IsExif() == true {
return i, s, nil
}
}
return -1, nil, exif.ErrNoExif
}
// FindXmp returns the the segment that hosts the XMP data (if present).
func (sl *SegmentList) FindXmp() (index int, segment *Segment, err error) {
defer func() {
if state := recover(); state != nil {
err = log.Wrap(state.(error))
}
}()
for i, s := range sl.segments {
if s.IsXmp() == true {
return i, s, nil
}
}
return -1, nil, ErrNoXmp
}
// FindIptc returns the the segment that hosts the IPTC data (if present).
func (sl *SegmentList) FindIptc() (index int, segment *Segment, err error) {
defer func() {
if state := recover(); state != nil {
err = log.Wrap(state.(error))
}
}()
for i, s := range sl.segments {
if s.IsIptc() == true {
return i, s, nil
}
}
return -1, nil, ErrNoIptc
}
// Exif returns an `exif.Ifd` instance for the EXIF data we currently have.
func (sl *SegmentList) Exif() (rootIfd *exif.Ifd, rawExif []byte, err error) {
defer func() {
if state := recover(); state != nil {
err = log.Wrap(state.(error))
}
}()
_, s, err := sl.FindExif()
log.PanicIf(err)
rootIfd, rawExif, err = s.Exif()
log.PanicIf(err)
return rootIfd, rawExif, nil
}
// Iptc returns embedded IPTC data if present.
func (sl *SegmentList) Iptc() (tags map[iptc.StreamTagKey][]iptc.TagData, err error) {
defer func() {
if state := recover(); state != nil {
err = log.Wrap(state.(error))
}
}()
// TODO(dustin): Add comment and return data.
_, s, err := sl.FindIptc()
log.PanicIf(err)
tags, err = s.Iptc()
log.PanicIf(err)
return tags, nil
}
// ConstructExifBuilder returns an `exif.IfdBuilder` instance (needed for
// modifying) preloaded with all existing tags.
func (sl *SegmentList) ConstructExifBuilder() (rootIb *exif.IfdBuilder, err error) {
defer func() {
if state := recover(); state != nil {
err = log.Wrap(state.(error))
}
}()
rootIfd, _, err := sl.Exif()
log.PanicIf(err)
ib := exif.NewIfdBuilderFromExistingChain(rootIfd)
return ib, nil
}
// DumpExif returns an unstructured list of tags (useful when just reviewing).
func (sl *SegmentList) DumpExif() (segmentIndex int, segment *Segment, exifTags []exif.ExifTag, err error) {
defer func() {
if state := recover(); state != nil {
err = log.Wrap(state.(error))
}
}()
segmentIndex, s, err := sl.FindExif()
if err != nil {
if err == exif.ErrNoExif {
return 0, nil, nil, err
}
log.Panic(err)
}
exifTags, err = s.FlatExif()
log.PanicIf(err)
return segmentIndex, s, exifTags, nil
}
func makeEmptyExifSegment() (s *Segment) {
// TODO(dustin): Add test
return &Segment{
MarkerId: MARKER_APP1,
}
}
// SetExif encodes and sets EXIF data into the given segment. If `index` is -1,
// append a new segment.
func (sl *SegmentList) SetExif(ib *exif.IfdBuilder) (err error) {
defer func() {
if state := recover(); state != nil {
err = log.Wrap(state.(error))
}
}()
_, s, err := sl.FindExif()
if err != nil {
if log.Is(err, exif.ErrNoExif) == false {
log.Panic(err)
}
s = makeEmptyExifSegment()
prefix := sl.segments[:1]
// Install it near the beginning where we know it's safe. We can't
// insert it after the EOI segment, and there might be more than one
// depending on implementation and/or lax adherence to the standard.
tail := append([]*Segment{s}, sl.segments[1:]...)
sl.segments = append(prefix, tail...)
}
err = s.SetExif(ib)
log.PanicIf(err)
return nil
}
// DropExif will drop the EXIF data if present.
func (sl *SegmentList) DropExif() (wasDropped bool, err error) {
defer func() {
if state := recover(); state != nil {
err = log.Wrap(state.(error))
}
}()
// TODO(dustin): Add test
i, _, err := sl.FindExif()
if err == nil {
// Found.
sl.segments = append(sl.segments[:i], sl.segments[i+1:]...)
return true, nil
} else if log.Is(err, exif.ErrNoExif) == false {
log.Panic(err)
}
// Not found.
return false, nil
}
// Write writes the segment data to the given `io.Writer`.
func (sl *SegmentList) Write(w io.Writer) (err error) {
defer func() {
if state := recover(); state != nil {
err = log.Wrap(state.(error))
}
}()
offset := 0
for i, s := range sl.segments {
h := sha1.New()
h.Write(s.Data)
// The scan-data will have a marker-ID of (0) because it doesn't have a
// marker-ID or length.
if s.MarkerId != 0 {
_, err := w.Write([]byte{0xff})
log.PanicIf(err)
offset++
_, err = w.Write([]byte{s.MarkerId})
log.PanicIf(err)
offset++
sizeLen, found := markerLen[s.MarkerId]
if found == false || sizeLen == 2 {
sizeLen = 2
l := uint16(len(s.Data) + sizeLen)
err = binary.Write(w, binary.BigEndian, &l)
log.PanicIf(err)
offset += 2
} else if sizeLen == 4 {
l := uint32(len(s.Data) + sizeLen)
err = binary.Write(w, binary.BigEndian, &l)
log.PanicIf(err)
offset += 4
} else if sizeLen != 0 {
log.Panicf("not a supported marker-size: SEGMENT-INDEX=(%d) MARKER-ID=(0x%02x) MARKER-SIZE-LEN=(%d)", i, s.MarkerId, sizeLen)
}
}
_, err := w.Write(s.Data)
log.PanicIf(err)
offset += len(s.Data)
}
return nil
}