diff options
Diffstat (limited to 'vendor/github.com/dsoprea/go-png-image-structure/v2')
7 files changed, 759 insertions, 0 deletions
diff --git a/vendor/github.com/dsoprea/go-png-image-structure/v2/.MODULE_ROOT b/vendor/github.com/dsoprea/go-png-image-structure/v2/.MODULE_ROOT new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/vendor/github.com/dsoprea/go-png-image-structure/v2/.MODULE_ROOT diff --git a/vendor/github.com/dsoprea/go-png-image-structure/v2/LICENSE b/vendor/github.com/dsoprea/go-png-image-structure/v2/LICENSE new file mode 100644 index 000000000..163291ed6 --- /dev/null +++ b/vendor/github.com/dsoprea/go-png-image-structure/v2/LICENSE @@ -0,0 +1,9 @@ +MIT LICENSE + +Copyright 2020 Dustin Oprea + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vendor/github.com/dsoprea/go-png-image-structure/v2/chunk_decoder.go b/vendor/github.com/dsoprea/go-png-image-structure/v2/chunk_decoder.go new file mode 100644 index 000000000..b5e0b1b16 --- /dev/null +++ b/vendor/github.com/dsoprea/go-png-image-structure/v2/chunk_decoder.go @@ -0,0 +1,87 @@ +package pngstructure + +import ( + "bytes" + "fmt" + + "encoding/binary" + + "github.com/dsoprea/go-logging" +) + +type ChunkDecoder struct { +} + +func NewChunkDecoder() *ChunkDecoder { + return new(ChunkDecoder) +} + +func (cd *ChunkDecoder) Decode(c *Chunk) (decoded interface{}, err error) { + defer func() { + if state := recover(); state != nil { + err := log.Wrap(state.(error)) + log.Panic(err) + } + }() + + switch c.Type { + case "IHDR": + ihdr, err := cd.decodeIHDR(c) + log.PanicIf(err) + + return ihdr, nil + } + + // We don't decode this particular type. + return nil, nil +} + +type ChunkIHDR struct { + Width uint32 + Height uint32 + BitDepth uint8 + ColorType uint8 + CompressionMethod uint8 + FilterMethod uint8 + InterlaceMethod uint8 +} + +func (ihdr *ChunkIHDR) String() string { + return fmt.Sprintf("IHDR<WIDTH=(%d) HEIGHT=(%d) DEPTH=(%d) COLOR-TYPE=(%d) COMP-METHOD=(%d) FILTER-METHOD=(%d) INTRLC-METHOD=(%d)>", ihdr.Width, ihdr.Height, ihdr.BitDepth, ihdr.ColorType, ihdr.CompressionMethod, ihdr.FilterMethod, ihdr.InterlaceMethod) +} + +func (cd *ChunkDecoder) decodeIHDR(c *Chunk) (ihdr *ChunkIHDR, err error) { + defer func() { + if state := recover(); state != nil { + err := log.Wrap(state.(error)) + log.Panic(err) + } + }() + + b := bytes.NewBuffer(c.Data) + + ihdr = new(ChunkIHDR) + + err = binary.Read(b, binary.BigEndian, &ihdr.Width) + log.PanicIf(err) + + err = binary.Read(b, binary.BigEndian, &ihdr.Height) + log.PanicIf(err) + + err = binary.Read(b, binary.BigEndian, &ihdr.BitDepth) + log.PanicIf(err) + + err = binary.Read(b, binary.BigEndian, &ihdr.ColorType) + log.PanicIf(err) + + err = binary.Read(b, binary.BigEndian, &ihdr.CompressionMethod) + log.PanicIf(err) + + err = binary.Read(b, binary.BigEndian, &ihdr.FilterMethod) + log.PanicIf(err) + + err = binary.Read(b, binary.BigEndian, &ihdr.InterlaceMethod) + log.PanicIf(err) + + return ihdr, nil +} diff --git a/vendor/github.com/dsoprea/go-png-image-structure/v2/media_parser.go b/vendor/github.com/dsoprea/go-png-image-structure/v2/media_parser.go new file mode 100644 index 000000000..c0e287365 --- /dev/null +++ b/vendor/github.com/dsoprea/go-png-image-structure/v2/media_parser.go @@ -0,0 +1,118 @@ +package pngstructure + +import ( + "bufio" + "bytes" + "image" + "io" + "os" + + "image/png" + + "github.com/dsoprea/go-logging" + "github.com/dsoprea/go-utility/v2/image" +) + +// PngMediaParser knows how to parse a PNG stream. +type PngMediaParser struct { +} + +// NewPngMediaParser returns a new `PngMediaParser` struct. +func NewPngMediaParser() *PngMediaParser { + + // TODO(dustin): Add test + + return new(PngMediaParser) +} + +// Parse parses a PNG stream given a `io.ReadSeeker`. +func (pmp *PngMediaParser) Parse(rs io.ReadSeeker, size int) (mc riimage.MediaContext, err error) { + defer func() { + if state := recover(); state != nil { + err = log.Wrap(state.(error)) + } + }() + + // TODO(dustin): Add test + + ps := NewPngSplitter() + + err = ps.readHeader(rs) + log.PanicIf(err) + + s := bufio.NewScanner(rs) + + // Since each segment can be any size, our buffer must be allowed to grow + // as large as the file. + buffer := []byte{} + s.Buffer(buffer, size) + s.Split(ps.Split) + + for s.Scan() != false { + } + + log.PanicIf(s.Err()) + + return ps.Chunks(), nil +} + +// ParseFile parses a PNG stream given a file-path. +func (pmp *PngMediaParser) ParseFile(filepath string) (mc riimage.MediaContext, err error) { + defer func() { + if state := recover(); state != nil { + err = log.Wrap(state.(error)) + } + }() + + f, err := os.Open(filepath) + log.PanicIf(err) + + defer f.Close() + + stat, err := f.Stat() + log.PanicIf(err) + + size := stat.Size() + + chunks, err := pmp.Parse(f, int(size)) + log.PanicIf(err) + + return chunks, nil +} + +// ParseBytes parses a PNG stream given a byte-slice. +func (pmp *PngMediaParser) ParseBytes(data []byte) (mc riimage.MediaContext, err error) { + defer func() { + if state := recover(); state != nil { + err = log.Wrap(state.(error)) + } + }() + + // TODO(dustin): Add test + + br := bytes.NewReader(data) + + chunks, err := pmp.Parse(br, len(data)) + log.PanicIf(err) + + return chunks, nil +} + +// LooksLikeFormat returns a boolean indicating whether the stream looks like a +// PNG image. +func (pmp *PngMediaParser) LooksLikeFormat(data []byte) bool { + return bytes.Compare(data[:len(PngSignature)], PngSignature[:]) == 0 +} + +// GetImage returns an image.Image-compatible struct. +func (pmp *PngMediaParser) GetImage(r io.Reader) (img image.Image, err error) { + img, err = png.Decode(r) + log.PanicIf(err) + + return img, nil +} + +var ( + // Enforce interface conformance. + _ riimage.MediaParser = new(PngMediaParser) +) diff --git a/vendor/github.com/dsoprea/go-png-image-structure/v2/png.go b/vendor/github.com/dsoprea/go-png-image-structure/v2/png.go new file mode 100644 index 000000000..fbb022887 --- /dev/null +++ b/vendor/github.com/dsoprea/go-png-image-structure/v2/png.go @@ -0,0 +1,416 @@ +package pngstructure + +import ( + "bytes" + "errors" + "fmt" + "io" + + "encoding/binary" + "hash/crc32" + + "github.com/dsoprea/go-exif/v3" + "github.com/dsoprea/go-exif/v3/common" + "github.com/dsoprea/go-logging" + "github.com/dsoprea/go-utility/v2/image" +) + +var ( + PngSignature = [8]byte{137, 'P', 'N', 'G', '\r', '\n', 26, '\n'} + EXifChunkType = "eXIf" + IHDRChunkType = "IHDR" +) + +var ( + ErrNotPng = errors.New("not png data") + ErrCrcFailure = errors.New("crc failure") +) + +// ChunkSlice encapsulates a slice of chunks. +type ChunkSlice struct { + chunks []*Chunk +} + +func NewChunkSlice(chunks []*Chunk) *ChunkSlice { + if len(chunks) == 0 { + log.Panicf("ChunkSlice must be initialized with at least one chunk (IHDR)") + } else if chunks[0].Type != IHDRChunkType { + log.Panicf("first chunk in any ChunkSlice must be an IHDR") + } + + return &ChunkSlice{ + chunks: chunks, + } +} + +func NewPngChunkSlice() *ChunkSlice { + + ihdrChunk := &Chunk{ + Type: IHDRChunkType, + } + + ihdrChunk.UpdateCrc32() + + return NewChunkSlice([]*Chunk{ihdrChunk}) +} + +func (cs *ChunkSlice) String() string { + return fmt.Sprintf("ChunkSlize<LEN=(%d)>", len(cs.chunks)) +} + +// Chunks exposes the actual slice. +func (cs *ChunkSlice) Chunks() []*Chunk { + return cs.chunks +} + +// Write encodes and writes all chunks. +func (cs *ChunkSlice) WriteTo(w io.Writer) (err error) { + defer func() { + if state := recover(); state != nil { + err = log.Wrap(state.(error)) + } + }() + + _, err = w.Write(PngSignature[:]) + log.PanicIf(err) + + // TODO(dustin): !! This should respect the safe-to-copy characteristic. + for _, c := range cs.chunks { + _, err := c.WriteTo(w) + log.PanicIf(err) + } + + return nil +} + +// Index returns a map of chunk types to chunk slices, grouping all like chunks. +func (cs *ChunkSlice) Index() (index map[string][]*Chunk) { + index = make(map[string][]*Chunk) + for _, c := range cs.chunks { + if grouped, found := index[c.Type]; found == true { + index[c.Type] = append(grouped, c) + } else { + index[c.Type] = []*Chunk{c} + } + } + + return index +} + +// FindExif returns the the segment that hosts the EXIF data. +func (cs *ChunkSlice) FindExif() (chunk *Chunk, err error) { + defer func() { + if state := recover(); state != nil { + err = log.Wrap(state.(error)) + } + }() + + index := cs.Index() + + if chunks, found := index[EXifChunkType]; found == true { + return chunks[0], nil + } + + log.Panic(exif.ErrNoExif) + + // Never called. + return nil, nil +} + +// Exif returns an `exif.Ifd` instance with the existing tags. +func (cs *ChunkSlice) Exif() (rootIfd *exif.Ifd, data []byte, err error) { + defer func() { + if state := recover(); state != nil { + err = log.Wrap(state.(error)) + } + }() + + chunk, err := cs.FindExif() + log.PanicIf(err) + + im, err := exifcommon.NewIfdMappingWithStandard() + log.PanicIf(err) + + ti := exif.NewTagIndex() + + // TODO(dustin): Refactor and support `exif.GetExifData()`. + + _, index, err := exif.Collect(im, ti, chunk.Data) + log.PanicIf(err) + + return index.RootIfd, chunk.Data, nil +} + +// ConstructExifBuilder returns an `exif.IfdBuilder` instance (needed for +// modifying) preloaded with all existing tags. +func (cs *ChunkSlice) ConstructExifBuilder() (rootIb *exif.IfdBuilder, err error) { + defer func() { + if state := recover(); state != nil { + err = log.Wrap(state.(error)) + } + }() + + rootIfd, _, err := cs.Exif() + log.PanicIf(err) + + ib := exif.NewIfdBuilderFromExistingChain(rootIfd) + + return ib, nil +} + +// SetExif encodes and sets EXIF data into this segment. +func (cs *ChunkSlice) SetExif(ib *exif.IfdBuilder) (err error) { + defer func() { + if state := recover(); state != nil { + err = log.Wrap(state.(error)) + } + }() + + // Encode. + + ibe := exif.NewIfdByteEncoder() + + exifData, err := ibe.EncodeToExif(ib) + log.PanicIf(err) + + // Set. + + exifChunk, err := cs.FindExif() + if err == nil { + // EXIF chunk already exists. + + exifChunk.Data = exifData + exifChunk.Length = uint32(len(exifData)) + } else { + if log.Is(err, exif.ErrNoExif) != true { + log.Panic(err) + } + + // Add a EXIF chunk for the first time. + + exifChunk = &Chunk{ + Type: EXifChunkType, + Data: exifData, + Length: uint32(len(exifData)), + } + + // Insert it after the IHDR chunk (it's a reliably appropriate place to + // put it). + cs.chunks = append(cs.chunks[:1], append([]*Chunk{exifChunk}, cs.chunks[1:]...)...) + } + + exifChunk.UpdateCrc32() + + return nil +} + +// PngSplitter hosts the princpal `Split()` method uses by `bufio.Scanner`. +type PngSplitter struct { + chunks []*Chunk + currentOffset int + + doCheckCrc bool + crcErrors []string +} + +func (ps *PngSplitter) Chunks() *ChunkSlice { + return NewChunkSlice(ps.chunks) +} + +func (ps *PngSplitter) DoCheckCrc(doCheck bool) { + ps.doCheckCrc = doCheck +} + +func (ps *PngSplitter) CrcErrors() []string { + return ps.crcErrors +} + +func NewPngSplitter() *PngSplitter { + return &PngSplitter{ + chunks: make([]*Chunk, 0), + doCheckCrc: true, + crcErrors: make([]string, 0), + } +} + +// Chunk describes a single chunk. +type Chunk struct { + Offset int + Length uint32 + Type string + Data []byte + Crc uint32 +} + +func (c *Chunk) String() string { + return fmt.Sprintf("Chunk<OFFSET=(%d) LENGTH=(%d) TYPE=[%s] CRC=(%d)>", c.Offset, c.Length, c.Type, c.Crc) +} + +func calculateCrc32(chunk *Chunk) uint32 { + c := crc32.NewIEEE() + + c.Write([]byte(chunk.Type)) + c.Write(chunk.Data) + + return c.Sum32() +} + +func (c *Chunk) UpdateCrc32() { + c.Crc = calculateCrc32(c) +} + +func (c *Chunk) CheckCrc32() bool { + expected := calculateCrc32(c) + return c.Crc == expected +} + +// Bytes encodes and returns the bytes for this chunk. +func (c *Chunk) Bytes() []byte { + defer func() { + if state := recover(); state != nil { + err := log.Wrap(state.(error)) + log.Panic(err) + } + }() + + if len(c.Data) != int(c.Length) { + log.Panicf("length of data not correct") + } + + preallocated := make([]byte, 0, 4+4+c.Length+4) + b := bytes.NewBuffer(preallocated) + + err := binary.Write(b, binary.BigEndian, c.Length) + log.PanicIf(err) + + _, err = b.Write([]byte(c.Type)) + log.PanicIf(err) + + if c.Data != nil { + _, err = b.Write(c.Data) + log.PanicIf(err) + } + + err = binary.Write(b, binary.BigEndian, c.Crc) + log.PanicIf(err) + + return b.Bytes() +} + +// Write encodes and writes the bytes for this chunk. +func (c *Chunk) WriteTo(w io.Writer) (count int, err error) { + defer func() { + if state := recover(); state != nil { + err = log.Wrap(state.(error)) + } + }() + + if len(c.Data) != int(c.Length) { + log.Panicf("length of data not correct") + } + + err = binary.Write(w, binary.BigEndian, c.Length) + log.PanicIf(err) + + _, err = w.Write([]byte(c.Type)) + log.PanicIf(err) + + _, err = w.Write(c.Data) + log.PanicIf(err) + + err = binary.Write(w, binary.BigEndian, c.Crc) + log.PanicIf(err) + + return 4 + len(c.Type) + len(c.Data) + 4, nil +} + +// readHeader verifies that the PNG header bytes appear next. +func (ps *PngSplitter) readHeader(r io.Reader) (err error) { + defer func() { + if state := recover(); state != nil { + err = log.Wrap(state.(error)) + } + }() + + len_ := len(PngSignature) + header := make([]byte, len_) + + _, err = r.Read(header) + log.PanicIf(err) + + ps.currentOffset += len_ + + if bytes.Compare(header, PngSignature[:]) != 0 { + log.Panic(ErrNotPng) + } + + return nil +} + +// Split fulfills the `bufio.SplitFunc` function definition for +// `bufio.Scanner`. +func (ps *PngSplitter) Split(data []byte, atEOF bool) (advance int, token []byte, err error) { + defer func() { + if state := recover(); state != nil { + err = log.Wrap(state.(error)) + } + }() + + // We might have more than one chunk's worth, and, if `atEOF` is true, we + // won't be called again. We'll repeatedly try to read additional chunks, + // but, when we run out of the data we were given then we'll return the + // number of bytes fo rthe chunks we've already completely read. Then, + // we'll be called again from theend ofthose bytes, at which point we'll + // indicate that we don't yet have enough for another chunk, and we should + // be then called with more. + for { + len_ := len(data) + if len_ < 8 { + return advance, nil, nil + } + + length := binary.BigEndian.Uint32(data[:4]) + type_ := string(data[4:8]) + chunkSize := (8 + int(length) + 4) + + if len_ < chunkSize { + return advance, nil, nil + } + + crcIndex := 8 + length + crc := binary.BigEndian.Uint32(data[crcIndex : crcIndex+4]) + + content := make([]byte, length) + copy(content, data[8:8+length]) + + c := &Chunk{ + Length: length, + Type: type_, + Data: content, + Crc: crc, + Offset: ps.currentOffset, + } + + ps.chunks = append(ps.chunks, c) + + if c.CheckCrc32() == false { + ps.crcErrors = append(ps.crcErrors, type_) + + if ps.doCheckCrc == true { + log.Panic(ErrCrcFailure) + } + } + + advance += chunkSize + ps.currentOffset += chunkSize + + data = data[chunkSize:] + } + + return advance, nil, nil +} + +var ( + // Enforce interface conformance. + _ riimage.MediaContext = new(ChunkSlice) +) diff --git a/vendor/github.com/dsoprea/go-png-image-structure/v2/testing_common.go b/vendor/github.com/dsoprea/go-png-image-structure/v2/testing_common.go new file mode 100644 index 000000000..9df13a858 --- /dev/null +++ b/vendor/github.com/dsoprea/go-png-image-structure/v2/testing_common.go @@ -0,0 +1,64 @@ +package pngstructure + +import ( + "os" + "path" + + "github.com/dsoprea/go-logging" +) + +var ( + assetsPath = "" +) + +func getModuleRootPath() string { + moduleRootPath := os.Getenv("PNG_MODULE_ROOT_PATH") + if moduleRootPath != "" { + return moduleRootPath + } + + currentWd, err := os.Getwd() + log.PanicIf(err) + + currentPath := currentWd + visited := make([]string, 0) + + for { + tryStampFilepath := path.Join(currentPath, ".MODULE_ROOT") + + _, err := os.Stat(tryStampFilepath) + if err != nil && os.IsNotExist(err) != true { + log.Panic(err) + } else if err == nil { + break + } + + visited = append(visited, tryStampFilepath) + + currentPath = path.Dir(currentPath) + if currentPath == "/" { + log.Panicf("could not find module-root: %v", visited) + } + } + + return currentPath +} + +func getTestAssetsPath() string { + if assetsPath == "" { + moduleRootPath := getModuleRootPath() + assetsPath = path.Join(moduleRootPath, "assets") + } + + return assetsPath +} + +func getTestBasicImageFilepath() string { + assetsPath := getTestAssetsPath() + return path.Join(assetsPath, "libpng.png") +} + +func getTestExifImageFilepath() string { + assetsPath := getTestAssetsPath() + return path.Join(assetsPath, "exif.png") +} diff --git a/vendor/github.com/dsoprea/go-png-image-structure/v2/utility.go b/vendor/github.com/dsoprea/go-png-image-structure/v2/utility.go new file mode 100644 index 000000000..dbff145a6 --- /dev/null +++ b/vendor/github.com/dsoprea/go-png-image-structure/v2/utility.go @@ -0,0 +1,65 @@ +package pngstructure + +import ( + "bytes" + "fmt" + + "github.com/dsoprea/go-logging" +) + +func DumpBytes(data []byte) { + fmt.Printf("DUMP: ") + for _, x := range data { + fmt.Printf("%02x ", x) + } + + fmt.Printf("\n") +} + +func DumpBytesClause(data []byte) { + fmt.Printf("DUMP: ") + + fmt.Printf("[]byte { ") + + for i, x := range data { + fmt.Printf("0x%02x", x) + + if i < len(data)-1 { + fmt.Printf(", ") + } + } + + fmt.Printf(" }\n") +} + +func DumpBytesToString(data []byte) string { + b := new(bytes.Buffer) + + for i, x := range data { + _, err := b.WriteString(fmt.Sprintf("%02x", x)) + log.PanicIf(err) + + if i < len(data)-1 { + _, err := b.WriteRune(' ') + log.PanicIf(err) + } + } + + return b.String() +} + +func DumpBytesClauseToString(data []byte) string { + b := new(bytes.Buffer) + + for i, x := range data { + _, err := b.WriteString(fmt.Sprintf("0x%02x", x)) + log.PanicIf(err) + + if i < len(data)-1 { + _, err := b.WriteString(", ") + log.PanicIf(err) + } + } + + return b.String() +} |