io.go - external/github.com/disintegration/imaging - Git at Google

 package imaging

 import (
 	"encoding/binary"
 	"errors"
 	"image"
 	"image/draw"
 	"image/gif"
 	"image/jpeg"
 	"image/png"
 	"io"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"

 	"golang.org/x/image/bmp"
 	"golang.org/x/image/tiff"
 )

 // Format is an image file format.
 type Format int

 // Image file formats.
 const (
 	JPEG Format = iota
 	PNG
 	GIF
 	TIFF
 	BMP
 )

 func (f Format) String() string {
 	switch f {
 	case JPEG:
 		return "JPEG"
 	case PNG:
 		return "PNG"
 	case GIF:
 		return "GIF"
 	case TIFF:
 		return "TIFF"
 	case BMP:
 		return "BMP"
 	default:
 		return "Unsupported"
 	}
 }

 var formatFromExt = map[string]Format{
 	"jpg":  JPEG,
 	"jpeg": JPEG,
 	"png":  PNG,
 	"tif":  TIFF,
 	"tiff": TIFF,
 	"bmp":  BMP,
 	"gif":  GIF,
 }

 // FormatFromExtension parses image format from extension:
 // "jpg" (or "jpeg"), "png", "gif", "tif" (or "tiff") and "bmp" are supported.
 func FormatFromExtension(ext string) (Format, error) {
 	if f, ok := formatFromExt[strings.ToLower(strings.TrimPrefix(ext, "."))]; ok {
 		return f, nil
 	}
 	return -1, ErrUnsupportedFormat
 }

 // FormatFromFilename parses image format from filename extension:
 // "jpg" (or "jpeg"), "png", "gif", "tif" (or "tiff") and "bmp" are supported.
 func FormatFromFilename(filename string) (Format, error) {
 	ext := filepath.Ext(filename)
 	return FormatFromExtension(ext)
 }

 var (
 	// ErrUnsupportedFormat means the given image format (or file extension) is unsupported.
 	ErrUnsupportedFormat = errors.New("imaging: unsupported image format")
 )

 type fileSystem interface {
 	Create(string) (io.WriteCloser, error)
 	Open(string) (io.ReadCloser, error)
 }

 type localFS struct{}

 func (localFS) Create(name string) (io.WriteCloser, error) { return os.Create(name) }
 func (localFS) Open(name string) (io.ReadCloser, error)    { return os.Open(name) }

 var fs fileSystem = localFS{}

 type decodeConfig struct {
 	autoOrientation bool
 }

 var defaultDecodeConfig = decodeConfig{
 	autoOrientation: false,
 }

 // DecodeOption sets an optional parameter for the Decode and Open functions.
 type DecodeOption func(*decodeConfig)

 // AutoOrientation returns a DecodeOption that sets the auto-orientation mode.
 // If auto-orientation is enabled, the image will be transformed after decoding
 // according to the EXIF orientation tag (if present). By default it's disabled.
 func AutoOrientation(enabled bool) DecodeOption {
 	return func(c *decodeConfig) {
 		c.autoOrientation = enabled
 	}
 }

 // Decode reads an image from r.
 func Decode(r io.Reader, opts ...DecodeOption) (image.Image, error) {
 	cfg := defaultDecodeConfig
 	for _, option := range opts {
 		option(&cfg)
 	}

 	if !cfg.autoOrientation {
 		img, _, err := image.Decode(r)
 		return img, err
 	}

 	var orient orientation
 	pr, pw := io.Pipe()
 	r = io.TeeReader(r, pw)
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
 		orient = readOrientation(pr)
 		io.Copy(ioutil.Discard, pr)
 	}()

 	img, _, err := image.Decode(r)
 	pw.Close()
 	<-done
 	if err != nil {
 		return nil, err
 	}

 	return fixOrientation(img, orient), nil
 }

 // Open loads an image from file.
 //
 // Examples:
 //
 //	// Load an image from file.
 //	img, err := imaging.Open("test.jpg")
 //
 //	// Load an image and transform it depending on the EXIF orientation tag (if present).
 //	img, err := imaging.Open("test.jpg", imaging.AutoOrientation(true))
 //
 func Open(filename string, opts ...DecodeOption) (image.Image, error) {
 	file, err := fs.Open(filename)
 	if err != nil {
 		return nil, err
 	}
 	defer file.Close()
 	return Decode(file, opts...)
 }

 type encodeConfig struct {
 	jpegQuality         int
 	gifNumColors        int
 	gifQuantizer        draw.Quantizer
 	gifDrawer           draw.Drawer
 	pngCompressionLevel png.CompressionLevel
 }

 var defaultEncodeConfig = encodeConfig{
 	jpegQuality:         95,
 	gifNumColors:        256,
 	gifQuantizer:        nil,
 	gifDrawer:           nil,
 	pngCompressionLevel: png.DefaultCompression,
 }

 // EncodeOption sets an optional parameter for the Encode and Save functions.
 type EncodeOption func(*encodeConfig)

 // JPEGQuality returns an EncodeOption that sets the output JPEG quality.
 // Quality ranges from 1 to 100 inclusive, higher is better. Default is 95.
 func JPEGQuality(quality int) EncodeOption {
 	return func(c *encodeConfig) {
 		c.jpegQuality = quality
 	}
 }

 // GIFNumColors returns an EncodeOption that sets the maximum number of colors
 // used in the GIF-encoded image. It ranges from 1 to 256.  Default is 256.
 func GIFNumColors(numColors int) EncodeOption {
 	return func(c *encodeConfig) {
 		c.gifNumColors = numColors
 	}
 }

 // GIFQuantizer returns an EncodeOption that sets the quantizer that is used to produce
 // a palette of the GIF-encoded image.
 func GIFQuantizer(quantizer draw.Quantizer) EncodeOption {
 	return func(c *encodeConfig) {
 		c.gifQuantizer = quantizer
 	}
 }

 // GIFDrawer returns an EncodeOption that sets the drawer that is used to convert
 // the source image to the desired palette of the GIF-encoded image.
 func GIFDrawer(drawer draw.Drawer) EncodeOption {
 	return func(c *encodeConfig) {
 		c.gifDrawer = drawer
 	}
 }

 // PNGCompressionLevel returns an EncodeOption that sets the compression level
 // of the PNG-encoded image. Default is png.DefaultCompression.
 func PNGCompressionLevel(level png.CompressionLevel) EncodeOption {
 	return func(c *encodeConfig) {
 		c.pngCompressionLevel = level
 	}
 }

 // Encode writes the image img to w in the specified format (JPEG, PNG, GIF, TIFF or BMP).
 func Encode(w io.Writer, img image.Image, format Format, opts ...EncodeOption) error {
 	cfg := defaultEncodeConfig
 	for _, option := range opts {
 		option(&cfg)
 	}

 	var err error
 	switch format {
 	case JPEG:
 		var rgba *image.RGBA
 		if nrgba, ok := img.(*image.NRGBA); ok {
 			if nrgba.Opaque() {
 				rgba = &image.RGBA{
 					Pix:    nrgba.Pix,
 					Stride: nrgba.Stride,
 					Rect:   nrgba.Rect,
 				}
 			}
 		}
 		if rgba != nil {
 			err = jpeg.Encode(w, rgba, &jpeg.Options{Quality: cfg.jpegQuality})
 		} else {
 			err = jpeg.Encode(w, img, &jpeg.Options{Quality: cfg.jpegQuality})
 		}

 	case PNG:
 		enc := png.Encoder{CompressionLevel: cfg.pngCompressionLevel}
 		err = enc.Encode(w, img)

 	case GIF:
 		err = gif.Encode(w, img, &gif.Options{
 			NumColors: cfg.gifNumColors,
 			Quantizer: cfg.gifQuantizer,
 			Drawer:    cfg.gifDrawer,
 		})

 	case TIFF:
 		err = tiff.Encode(w, img, &tiff.Options{Compression: tiff.Deflate, Predictor: true})

 	case BMP:
 		err = bmp.Encode(w, img)

 	default:
 		err = ErrUnsupportedFormat
 	}
 	return err
 }

 // Save saves the image to file with the specified filename.
 // The format is determined from the filename extension:
 // "jpg" (or "jpeg"), "png", "gif", "tif" (or "tiff") and "bmp" are supported.
 //
 // Examples:
 //
 //	// Save the image as PNG.
 //	err := imaging.Save(img, "out.png")
 //
 //	// Save the image as JPEG with optional quality parameter set to 80.
 //	err := imaging.Save(img, "out.jpg", imaging.JPEGQuality(80))
 //
 func Save(img image.Image, filename string, opts ...EncodeOption) (err error) {
 	f, err := FormatFromFilename(filename)
 	if err != nil {
 		return err
 	}
 	file, err := fs.Create(filename)
 	if err != nil {
 		return err
 	}

 	defer func() {
 		cerr := file.Close()
 		if err == nil {
 			err = cerr
 		}
 	}()

 	return Encode(file, img, f, opts...)
 }

 // orientation is an EXIF flag that specifies the transformation
 // that should be applied to image to display it correctly.
 type orientation int

 const (
 	orientationUnspecified = 0
 	orientationNormal      = 1
 	orientationFlipH       = 2
 	orientationRotate180   = 3
 	orientationFlipV       = 4
 	orientationTranspose   = 5
 	orientationRotate270   = 6
 	orientationTransverse  = 7
 	orientationRotate90    = 8
 )

 // readOrientation tries to read the orientation EXIF flag from image data in r.
 // If the EXIF data block is not found or the orientation flag is not found
 // or any other error occures while reading the data, it returns the
 // orientationUnspecified (0) value.
 func readOrientation(r io.Reader) orientation {
 	const (
 		markerSOI      = 0xffd8
 		markerAPP1     = 0xffe1
 		exifHeader     = 0x45786966
 		byteOrderBE    = 0x4d4d
 		byteOrderLE    = 0x4949
 		orientationTag = 0x0112
 	)

 	// Check if JPEG SOI marker is present.
 	var soi uint16
 	if err := binary.Read(r, binary.BigEndian, &soi); err != nil {
 		return orientationUnspecified
 	}
 	if soi != markerSOI {
 		return orientationUnspecified // Missing JPEG SOI marker.
 	}

 	// Find JPEG APP1 marker.
 	for {
 		var marker, size uint16
 		if err := binary.Read(r, binary.BigEndian, &marker); err != nil {
 			return orientationUnspecified
 		}
 		if err := binary.Read(r, binary.BigEndian, &size); err != nil {
 			return orientationUnspecified
 		}
 		if marker>>8 != 0xff {
 			return orientationUnspecified // Invalid JPEG marker.
 		}
 		if marker == markerAPP1 {
 			break
 		}
 		if size < 2 {
 			return orientationUnspecified // Invalid block size.
 		}
 		if _, err := io.CopyN(ioutil.Discard, r, int64(size-2)); err != nil {
 			return orientationUnspecified
 		}
 	}

 	// Check if EXIF header is present.
 	var header uint32
 	if err := binary.Read(r, binary.BigEndian, &header); err != nil {
 		return orientationUnspecified
 	}
 	if header != exifHeader {
 		return orientationUnspecified
 	}
 	if _, err := io.CopyN(ioutil.Discard, r, 2); err != nil {
 		return orientationUnspecified
 	}

 	// Read byte order information.
 	var (
 		byteOrderTag uint16
 		byteOrder    binary.ByteOrder
 	)
 	if err := binary.Read(r, binary.BigEndian, &byteOrderTag); err != nil {
 		return orientationUnspecified
 	}
 	switch byteOrderTag {
 	case byteOrderBE:
 		byteOrder = binary.BigEndian
 	case byteOrderLE:
 		byteOrder = binary.LittleEndian
 	default:
 		return orientationUnspecified // Invalid byte order flag.
 	}
 	if _, err := io.CopyN(ioutil.Discard, r, 2); err != nil {
 		return orientationUnspecified
 	}

 	// Skip the EXIF offset.
 	var offset uint32
 	if err := binary.Read(r, byteOrder, &offset); err != nil {
 		return orientationUnspecified
 	}
 	if offset < 8 {
 		return orientationUnspecified // Invalid offset value.
 	}
 	if _, err := io.CopyN(ioutil.Discard, r, int64(offset-8)); err != nil {
 		return orientationUnspecified
 	}

 	// Read the number of tags.
 	var numTags uint16
 	if err := binary.Read(r, byteOrder, &numTags); err != nil {
 		return orientationUnspecified
 	}

 	// Find the orientation tag.
 	for i := 0; i < int(numTags); i++ {
 		var tag uint16
 		if err := binary.Read(r, byteOrder, &tag); err != nil {
 			return orientationUnspecified
 		}
 		if tag != orientationTag {
 			if _, err := io.CopyN(ioutil.Discard, r, 10); err != nil {
 				return orientationUnspecified
 			}
 			continue
 		}
 		if _, err := io.CopyN(ioutil.Discard, r, 6); err != nil {
 			return orientationUnspecified
 		}
 		var val uint16
 		if err := binary.Read(r, byteOrder, &val); err != nil {
 			return orientationUnspecified
 		}
 		if val < 1 || val > 8 {
 			return orientationUnspecified // Invalid tag value.
 		}
 		return orientation(val)
 	}
 	return orientationUnspecified // Missing orientation tag.
 }

 // fixOrientation applies a transform to img corresponding to the given orientation flag.
 func fixOrientation(img image.Image, o orientation) image.Image {
 	switch o {
 	case orientationNormal:
 	case orientationFlipH:
 		img = FlipH(img)
 	case orientationFlipV:
 		img = FlipV(img)
 	case orientationRotate90:
 		img = Rotate90(img)
 	case orientationRotate180:
 		img = Rotate180(img)
 	case orientationRotate270:
 		img = Rotate270(img)
 	case orientationTranspose:
 		img = Transpose(img)
 	case orientationTransverse:
 		img = Transverse(img)
 	}
 	return img
 }
	package imaging

	import (
	"encoding/binary"
	"errors"
	"image"
	"image/draw"
	"image/gif"
	"image/jpeg"
	"image/png"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"

	"golang.org/x/image/bmp"
	"golang.org/x/image/tiff"
	)

	// Format is an image file format.
	type Format int

	// Image file formats.
	const (
	JPEG Format = iota
	PNG
	GIF
	TIFF
	BMP
	)

	func (f Format) String() string {
	switch f {
	case JPEG:
	return "JPEG"
	case PNG:
	return "PNG"
	case GIF:
	return "GIF"
	case TIFF:
	return "TIFF"
	case BMP:
	return "BMP"
	default:
	return "Unsupported"
	}
	}

	var formatFromExt = map[string]Format{
	"jpg": JPEG,
	"jpeg": JPEG,
	"png": PNG,
	"tif": TIFF,
	"tiff": TIFF,
	"bmp": BMP,
	"gif": GIF,
	}

	// FormatFromExtension parses image format from extension:
	// "jpg" (or "jpeg"), "png", "gif", "tif" (or "tiff") and "bmp" are supported.
	func FormatFromExtension(ext string) (Format, error) {
	if f, ok := formatFromExt[strings.ToLower(strings.TrimPrefix(ext, "."))]; ok {
	return f, nil
	}
	return -1, ErrUnsupportedFormat
	}

	// FormatFromFilename parses image format from filename extension:
	// "jpg" (or "jpeg"), "png", "gif", "tif" (or "tiff") and "bmp" are supported.
	func FormatFromFilename(filename string) (Format, error) {
	ext := filepath.Ext(filename)
	return FormatFromExtension(ext)
	}

	var (
	// ErrUnsupportedFormat means the given image format (or file extension) is unsupported.
	ErrUnsupportedFormat = errors.New("imaging: unsupported image format")
	)

	type fileSystem interface {
	Create(string) (io.WriteCloser, error)
	Open(string) (io.ReadCloser, error)
	}

	type localFS struct{}

	func (localFS) Create(name string) (io.WriteCloser, error) { return os.Create(name) }
	func (localFS) Open(name string) (io.ReadCloser, error) { return os.Open(name) }

	var fs fileSystem = localFS{}

	type decodeConfig struct {
	autoOrientation bool
	}

	var defaultDecodeConfig = decodeConfig{
	autoOrientation: false,
	}

	// DecodeOption sets an optional parameter for the Decode and Open functions.
	type DecodeOption func(*decodeConfig)

	// AutoOrientation returns a DecodeOption that sets the auto-orientation mode.
	// If auto-orientation is enabled, the image will be transformed after decoding
	// according to the EXIF orientation tag (if present). By default it's disabled.
	func AutoOrientation(enabled bool) DecodeOption {
	return func(c *decodeConfig) {
	c.autoOrientation = enabled
	}
	}

	// Decode reads an image from r.
	func Decode(r io.Reader, opts ...DecodeOption) (image.Image, error) {
	cfg := defaultDecodeConfig
	for _, option := range opts {
	option(&cfg)
	}

	if !cfg.autoOrientation {
	img, _, err := image.Decode(r)
	return img, err
	}

	var orient orientation
	pr, pw := io.Pipe()
	r = io.TeeReader(r, pw)
	done := make(chan struct{})
	go func() {
	defer close(done)
	orient = readOrientation(pr)
	io.Copy(ioutil.Discard, pr)
	}()

	img, _, err := image.Decode(r)
	pw.Close()
	<-done
	if err != nil {
	return nil, err
	}

	return fixOrientation(img, orient), nil
	}

	// Open loads an image from file.
	//
	// Examples:
	//
	// // Load an image from file.
	// img, err := imaging.Open("test.jpg")
	//
	// // Load an image and transform it depending on the EXIF orientation tag (if present).
	// img, err := imaging.Open("test.jpg", imaging.AutoOrientation(true))
	//
	func Open(filename string, opts ...DecodeOption) (image.Image, error) {
	file, err := fs.Open(filename)
	if err != nil {
	return nil, err
	}
	defer file.Close()
	return Decode(file, opts...)
	}

	type encodeConfig struct {
	jpegQuality int
	gifNumColors int
	gifQuantizer draw.Quantizer
	gifDrawer draw.Drawer
	pngCompressionLevel png.CompressionLevel
	}

	var defaultEncodeConfig = encodeConfig{
	jpegQuality: 95,
	gifNumColors: 256,
	gifQuantizer: nil,
	gifDrawer: nil,
	pngCompressionLevel: png.DefaultCompression,
	}

	// EncodeOption sets an optional parameter for the Encode and Save functions.
	type EncodeOption func(*encodeConfig)

	// JPEGQuality returns an EncodeOption that sets the output JPEG quality.
	// Quality ranges from 1 to 100 inclusive, higher is better. Default is 95.
	func JPEGQuality(quality int) EncodeOption {
	return func(c *encodeConfig) {
	c.jpegQuality = quality
	}
	}

	// GIFNumColors returns an EncodeOption that sets the maximum number of colors
	// used in the GIF-encoded image. It ranges from 1 to 256. Default is 256.
	func GIFNumColors(numColors int) EncodeOption {
	return func(c *encodeConfig) {
	c.gifNumColors = numColors
	}
	}

	// GIFQuantizer returns an EncodeOption that sets the quantizer that is used to produce
	// a palette of the GIF-encoded image.
	func GIFQuantizer(quantizer draw.Quantizer) EncodeOption {
	return func(c *encodeConfig) {
	c.gifQuantizer = quantizer
	}
	}

	// GIFDrawer returns an EncodeOption that sets the drawer that is used to convert
	// the source image to the desired palette of the GIF-encoded image.
	func GIFDrawer(drawer draw.Drawer) EncodeOption {
	return func(c *encodeConfig) {
	c.gifDrawer = drawer
	}
	}

	// PNGCompressionLevel returns an EncodeOption that sets the compression level
	// of the PNG-encoded image. Default is png.DefaultCompression.
	func PNGCompressionLevel(level png.CompressionLevel) EncodeOption {
	return func(c *encodeConfig) {
	c.pngCompressionLevel = level
	}
	}

	// Encode writes the image img to w in the specified format (JPEG, PNG, GIF, TIFF or BMP).
	func Encode(w io.Writer, img image.Image, format Format, opts ...EncodeOption) error {
	cfg := defaultEncodeConfig
	for _, option := range opts {
	option(&cfg)
	}

	var err error
	switch format {
	case JPEG:
	var rgba *image.RGBA
	if nrgba, ok := img.(*image.NRGBA); ok {
	if nrgba.Opaque() {
	rgba = &image.RGBA{
	Pix: nrgba.Pix,
	Stride: nrgba.Stride,
	Rect: nrgba.Rect,
	}
	}
	}
	if rgba != nil {
	err = jpeg.Encode(w, rgba, &jpeg.Options{Quality: cfg.jpegQuality})
	} else {
	err = jpeg.Encode(w, img, &jpeg.Options{Quality: cfg.jpegQuality})
	}

	case PNG:
	enc := png.Encoder{CompressionLevel: cfg.pngCompressionLevel}
	err = enc.Encode(w, img)

	case GIF:
	err = gif.Encode(w, img, &gif.Options{
	NumColors: cfg.gifNumColors,
	Quantizer: cfg.gifQuantizer,
	Drawer: cfg.gifDrawer,
	})

	case TIFF:
	err = tiff.Encode(w, img, &tiff.Options{Compression: tiff.Deflate, Predictor: true})

	case BMP:
	err = bmp.Encode(w, img)

	default:
	err = ErrUnsupportedFormat
	}
	return err
	}

	// Save saves the image to file with the specified filename.
	// The format is determined from the filename extension:
	// "jpg" (or "jpeg"), "png", "gif", "tif" (or "tiff") and "bmp" are supported.
	//
	// Examples:
	//
	// // Save the image as PNG.
	// err := imaging.Save(img, "out.png")
	//
	// // Save the image as JPEG with optional quality parameter set to 80.
	// err := imaging.Save(img, "out.jpg", imaging.JPEGQuality(80))
	//
	func Save(img image.Image, filename string, opts ...EncodeOption) (err error) {
	f, err := FormatFromFilename(filename)
	if err != nil {
	return err
	}
	file, err := fs.Create(filename)
	if err != nil {
	return err
	}

	defer func() {
	cerr := file.Close()
	if err == nil {
	err = cerr
	}
	}()

	return Encode(file, img, f, opts...)
	}

	// orientation is an EXIF flag that specifies the transformation
	// that should be applied to image to display it correctly.
	type orientation int

	const (
	orientationUnspecified = 0
	orientationNormal = 1
	orientationFlipH = 2
	orientationRotate180 = 3
	orientationFlipV = 4
	orientationTranspose = 5
	orientationRotate270 = 6
	orientationTransverse = 7
	orientationRotate90 = 8
	)

	// readOrientation tries to read the orientation EXIF flag from image data in r.
	// If the EXIF data block is not found or the orientation flag is not found
	// or any other error occures while reading the data, it returns the
	// orientationUnspecified (0) value.
	func readOrientation(r io.Reader) orientation {
	const (
	markerSOI = 0xffd8
	markerAPP1 = 0xffe1
	exifHeader = 0x45786966
	byteOrderBE = 0x4d4d
	byteOrderLE = 0x4949
	orientationTag = 0x0112
	)

	// Check if JPEG SOI marker is present.
	var soi uint16
	if err := binary.Read(r, binary.BigEndian, &soi); err != nil {
	return orientationUnspecified
	}
	if soi != markerSOI {
	return orientationUnspecified // Missing JPEG SOI marker.
	}

	// Find JPEG APP1 marker.
	for {
	var marker, size uint16
	if err := binary.Read(r, binary.BigEndian, &marker); err != nil {
	return orientationUnspecified
	}
	if err := binary.Read(r, binary.BigEndian, &size); err != nil {
	return orientationUnspecified
	}
	if marker>>8 != 0xff {
	return orientationUnspecified // Invalid JPEG marker.
	}
	if marker == markerAPP1 {
	break
	}
	if size < 2 {
	return orientationUnspecified // Invalid block size.
	}
	if _, err := io.CopyN(ioutil.Discard, r, int64(size-2)); err != nil {
	return orientationUnspecified
	}
	}

	// Check if EXIF header is present.
	var header uint32
	if err := binary.Read(r, binary.BigEndian, &header); err != nil {
	return orientationUnspecified
	}
	if header != exifHeader {
	return orientationUnspecified
	}
	if _, err := io.CopyN(ioutil.Discard, r, 2); err != nil {
	return orientationUnspecified
	}

	// Read byte order information.
	var (
	byteOrderTag uint16
	byteOrder binary.ByteOrder
	)
	if err := binary.Read(r, binary.BigEndian, &byteOrderTag); err != nil {
	return orientationUnspecified
	}
	switch byteOrderTag {
	case byteOrderBE:
	byteOrder = binary.BigEndian
	case byteOrderLE:
	byteOrder = binary.LittleEndian
	default:
	return orientationUnspecified // Invalid byte order flag.
	}
	if _, err := io.CopyN(ioutil.Discard, r, 2); err != nil {
	return orientationUnspecified
	}

	// Skip the EXIF offset.
	var offset uint32
	if err := binary.Read(r, byteOrder, &offset); err != nil {
	return orientationUnspecified
	}
	if offset < 8 {
	return orientationUnspecified // Invalid offset value.
	}
	if _, err := io.CopyN(ioutil.Discard, r, int64(offset-8)); err != nil {
	return orientationUnspecified
	}

	// Read the number of tags.
	var numTags uint16
	if err := binary.Read(r, byteOrder, &numTags); err != nil {
	return orientationUnspecified
	}

	// Find the orientation tag.
	for i := 0; i < int(numTags); i++ {
	var tag uint16
	if err := binary.Read(r, byteOrder, &tag); err != nil {
	return orientationUnspecified
	}
	if tag != orientationTag {
	if _, err := io.CopyN(ioutil.Discard, r, 10); err != nil {
	return orientationUnspecified
	}
	continue
	}
	if _, err := io.CopyN(ioutil.Discard, r, 6); err != nil {
	return orientationUnspecified
	}
	var val uint16
	if err := binary.Read(r, byteOrder, &val); err != nil {
	return orientationUnspecified
	}
	if val < 1 \|\| val > 8 {
	return orientationUnspecified // Invalid tag value.
	}
	return orientation(val)
	}
	return orientationUnspecified // Missing orientation tag.
	}

	// fixOrientation applies a transform to img corresponding to the given orientation flag.
	func fixOrientation(img image.Image, o orientation) image.Image {
	switch o {
	case orientationNormal:
	case orientationFlipH:
	img = FlipH(img)
	case orientationFlipV:
	img = FlipV(img)
	case orientationRotate90:
	img = Rotate90(img)
	case orientationRotate180:
	img = Rotate180(img)
	case orientationRotate270:
	img = Rotate270(img)
	case orientationTranspose:
	img = Transpose(img)
	case orientationTransverse:
	img = Transverse(img)
	}
	return img
	}