MM-14617 Dependency upgrades and adding modules support. (#10517)

* Dependency upgrades and adding modules support.

* Commenting out file tests playload verification portion.

* Fixing viper.

* Fixing hclog.

vendor/github.com/disintegration/imaging/.travis.yml

@@ -4,6 +4,7 @@ go:
   - "1.8.x"
   - "1.9.x"
   - "1.10.x"
+  - "1.11.x"
 
 before_install:
   - go get github.com/mattn/goveralls

vendor/github.com/disintegration/imaging/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2012-2018 Grigory Dryapak
+Copyright (c) 2012 Grigory Dryapak
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ 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.
+SOFTWARE.

vendor/github.com/disintegration/imaging/README.md

@@ -8,19 +8,19 @@
 Package imaging provides basic image processing functions (resize, rotate, crop, brightness/contrast adjustments, etc.).
 
 All the image processing functions provided by the package accept any image type that implements `image.Image` interface
-as an input, and return a new image of `*image.NRGBA` type (32bit RGBA colors, not premultiplied by alpha).
+as an input, and return a new image of `*image.NRGBA` type (32bit RGBA colors, non-premultiplied alpha).
 
 ## Installation
 
     go get -u github.com/disintegration/imaging
-    
+
 ## Documentation
 
 http://godoc.org/github.com/disintegration/imaging
 
 ## Usage examples
 
-A few usage examples can be found below. See the documentation for the full list of supported functions. 
+A few usage examples can be found below. See the documentation for the full list of supported functions.
 
 ### Image resizing
 
@@ -39,13 +39,12 @@ dstImageFill := imaging.Fill(srcImage, 100, 100, imaging.Center, imaging.Lanczos
 ```
 
 Imaging supports image resizing using various resampling filters. The most notable ones:
-- `NearestNeighbor` - Fastest resampling filter, no antialiasing.
+- `Lanczos` - A high-quality resampling filter for photographic images yielding sharp results.
+- `CatmullRom` - A sharp cubic filter that is faster than Lanczos filter while providing similar results.
+- `MitchellNetravali` - A cubic filter that produces smoother results with less ringing artifacts than CatmullRom.
+- `Linear` - Bilinear resampling filter, produces smooth output. Faster than cubic filters.
 - `Box` - Simple and fast averaging filter appropriate for downscaling. When upscaling it's similar to NearestNeighbor.
-- `Linear` - Bilinear filter, smooth and reasonably fast.
-- `MitchellNetravali` - А smooth bicubic filter.
-- `CatmullRom` - A sharp bicubic filter.
-- `Gaussian` - Blurring filter that uses gaussian function, useful for noise removal.
-- `Lanczos` - High-quality resampling filter for photographic images yielding sharp results, slower than cubic filters.
+- `NearestNeighbor` - Fastest resampling filter, no antialiasing.
 
 The full list of supported filters:  NearestNeighbor, Box, Linear, Hermite, MitchellNetravali, CatmullRom, BSpline, Gaussian, Lanczos, Hann, Hamming, Blackman, Bartlett, Welch, Cosine. Custom filters can be created using ResampleFilter struct.
 
@@ -60,7 +59,7 @@ From faster (lower quality) to slower (higher quality):
 
 Filter                    | Resize result
 --------------------------|---------------------------------------------
-`imaging.NearestNeighbor` | ![dstImage](testdata/out_resize_nearest.png) 
+`imaging.NearestNeighbor` | ![dstImage](testdata/out_resize_nearest.png)
 `imaging.Linear`          | ![dstImage](testdata/out_resize_linear.png)
 `imaging.CatmullRom`      | ![dstImage](testdata/out_resize_catrom.png)
 `imaging.Lanczos`         | ![dstImage](testdata/out_resize_lanczos.png)
@@ -120,6 +119,16 @@ Original image                     | Brightness = 10
 -----------------------------------|----------------------------------------------|---------------------------------------------
 ![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_brightness_p10.png) | ![dstImage](testdata/out_brightness_m10.png)
 
+### Saturation adjustment
+
+```go
+dstImage := imaging.AdjustSaturation(srcImage, 20)
+```
+
+Original image                     | Saturation = 30                              | Saturation = -30
+-----------------------------------|----------------------------------------------|---------------------------------------------
+![srcImage](testdata/flowers_small.png) | ![dstImage](testdata/out_saturation_p30.png) | ![dstImage](testdata/out_saturation_m30.png)
+
 ## Example code
 
 ```go
@@ -185,4 +194,4 @@ func main() {
 
 Output:
 
-![dstImage](testdata/out_example.jpg)
+![dstImage](testdata/out_example.jpg)

vendor/github.com/disintegration/imaging/adjust.go

@@ -15,14 +15,15 @@ func Grayscale(img image.Image) *image.NRGBA {
 			i := y * dst.Stride
 			src.scan(0, y, src.w, y+1, dst.Pix[i:i+src.w*4])
 			for x := 0; x < src.w; x++ {
-				r := dst.Pix[i+0]
-				g := dst.Pix[i+1]
-				b := dst.Pix[i+2]
+				d := dst.Pix[i : i+3 : i+3]
+				r := d[0]
+				g := d[1]
+				b := d[2]
 				f := 0.299*float64(r) + 0.587*float64(g) + 0.114*float64(b)
 				y := uint8(f + 0.5)
-				dst.Pix[i+0] = y
-				dst.Pix[i+1] = y
-				dst.Pix[i+2] = y
+				d[0] = y
+				d[1] = y
+				d[2] = y
 				i += 4
 			}
 		}
@@ -39,9 +40,10 @@ func Invert(img image.Image) *image.NRGBA {
 			i := y * dst.Stride
 			src.scan(0, y, src.w, y+1, dst.Pix[i:i+src.w*4])
 			for x := 0; x < src.w; x++ {
-				dst.Pix[i+0] = 255 - dst.Pix[i+0]
-				dst.Pix[i+1] = 255 - dst.Pix[i+1]
-				dst.Pix[i+2] = 255 - dst.Pix[i+2]
+				d := dst.Pix[i : i+3 : i+3]
+				d[0] = 255 - d[0]
+				d[1] = 255 - d[1]
+				d[2] = 255 - d[2]
 				i += 4
 			}
 		}
@@ -49,14 +51,39 @@ func Invert(img image.Image) *image.NRGBA {
 	return dst
 }
 
+// AdjustSaturation changes the saturation of the image using the percentage parameter and returns the adjusted image.
+// The percentage must be in the range (-100, 100).
+// The percentage = 0 gives the original image.
+// The percentage = 100 gives the image with the saturation value doubled for each pixel.
+// The percentage = -100 gives the image with the saturation value zeroed for each pixel (grayscale).
+//
+// Examples:
+//  dstImage = imaging.AdjustSaturation(srcImage, 25) // Increase image saturation by 25%.
+//  dstImage = imaging.AdjustSaturation(srcImage, -10) // Decrease image saturation by 10%.
+//
+func AdjustSaturation(img image.Image, percentage float64) *image.NRGBA {
+	percentage = math.Min(math.Max(percentage, -100), 100)
+	multiplier := 1 + percentage/100
+
+	return AdjustFunc(img, func(c color.NRGBA) color.NRGBA {
+		h, s, l := rgbToHSL(c.R, c.G, c.B)
+		s *= multiplier
+		if s > 1 {
+			s = 1
+		}
+		r, g, b := hslToRGB(h, s, l)
+		return color.NRGBA{r, g, b, c.A}
+	})
+}
+
 // AdjustContrast changes the contrast of the image using the percentage parameter and returns the adjusted image.
 // The percentage must be in range (-100, 100). The percentage = 0 gives the original image.
 // The percentage = -100 gives solid gray image.
 //
 // Examples:
 //
-//	dstImage = imaging.AdjustContrast(srcImage, -10) // decrease image contrast by 10%
-//	dstImage = imaging.AdjustContrast(srcImage, 20) // increase image contrast by 20%
+//	dstImage = imaging.AdjustContrast(srcImage, -10) // Decrease image contrast by 10%.
+//	dstImage = imaging.AdjustContrast(srcImage, 20) // Increase image contrast by 20%.
 //
 func AdjustContrast(img image.Image, percentage float64) *image.NRGBA {
 	percentage = math.Min(math.Max(percentage, -100.0), 100.0)
@@ -82,8 +109,8 @@ func AdjustContrast(img image.Image, percentage float64) *image.NRGBA {
 //
 // Examples:
 //
-//	dstImage = imaging.AdjustBrightness(srcImage, -15) // decrease image brightness by 15%
-//	dstImage = imaging.AdjustBrightness(srcImage, 10) // increase image brightness by 10%
+//	dstImage = imaging.AdjustBrightness(srcImage, -15) // Decrease image brightness by 15%.
+//	dstImage = imaging.AdjustBrightness(srcImage, 10) // Increase image brightness by 10%.
 //
 func AdjustBrightness(img image.Image, percentage float64) *image.NRGBA {
 	percentage = math.Min(math.Max(percentage, -100.0), 100.0)
@@ -124,8 +151,8 @@ func AdjustGamma(img image.Image, gamma float64) *image.NRGBA {
 //
 // Examples:
 //
-//	dstImage = imaging.AdjustSigmoid(srcImage, 0.5, 3.0) // increase the contrast
-//	dstImage = imaging.AdjustSigmoid(srcImage, 0.5, -3.0) // decrease the contrast
+//	dstImage = imaging.AdjustSigmoid(srcImage, 0.5, 3.0) // Increase the contrast.
+//	dstImage = imaging.AdjustSigmoid(srcImage, 0.5, -3.0) // Decrease the contrast.
 //
 func AdjustSigmoid(img image.Image, midpoint, factor float64) *image.NRGBA {
 	if factor == 0 {
@@ -166,14 +193,16 @@ func sigmoid(a, b, x float64) float64 {
 func adjustLUT(img image.Image, lut []uint8) *image.NRGBA {
 	src := newScanner(img)
 	dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))
+	lut = lut[0:256]
 	parallel(0, src.h, func(ys <-chan int) {
 		for y := range ys {
 			i := y * dst.Stride
 			src.scan(0, y, src.w, y+1, dst.Pix[i:i+src.w*4])
 			for x := 0; x < src.w; x++ {
-				dst.Pix[i+0] = lut[dst.Pix[i+0]]
-				dst.Pix[i+1] = lut[dst.Pix[i+1]]
-				dst.Pix[i+2] = lut[dst.Pix[i+2]]
+				d := dst.Pix[i : i+3 : i+3]
+				d[0] = lut[d[0]]
+				d[1] = lut[d[1]]
+				d[2] = lut[d[2]]
 				i += 4
 			}
 		}
@@ -188,7 +217,7 @@ func adjustLUT(img image.Image, lut []uint8) *image.NRGBA {
 //	dstImage = imaging.AdjustFunc(
 //		srcImage,
 //		func(c color.NRGBA) color.NRGBA {
-//			// shift the red channel by 16
+//			// Shift the red channel by 16.
 //			r := int(c.R) + 16
 //			if r > 255 {
 //				r = 255
@@ -205,15 +234,16 @@ func AdjustFunc(img image.Image, fn func(c color.NRGBA) color.NRGBA) *image.NRGB
 			i := y * dst.Stride
 			src.scan(0, y, src.w, y+1, dst.Pix[i:i+src.w*4])
 			for x := 0; x < src.w; x++ {
-				r := dst.Pix[i+0]
-				g := dst.Pix[i+1]
-				b := dst.Pix[i+2]
-				a := dst.Pix[i+3]
+				d := dst.Pix[i : i+4 : i+4]
+				r := d[0]
+				g := d[1]
+				b := d[2]
+				a := d[3]
 				c := fn(color.NRGBA{r, g, b, a})
-				dst.Pix[i+0] = c.R
-				dst.Pix[i+1] = c.G
-				dst.Pix[i+2] = c.B
-				dst.Pix[i+3] = c.A
+				d[0] = c.R
+				d[1] = c.G
+				d[2] = c.B
+				d[3] = c.A
 				i += 4
 			}
 		}

vendor/github.com/disintegration/imaging/convolution.go

@@ -90,9 +90,10 @@ func convolve(img image.Image, kernel []float64, options *ConvolveOptions) *imag
 					}
 
 					off := iy*src.Stride + ix*4
-					r += float64(src.Pix[off+0]) * c.k
-					g += float64(src.Pix[off+1]) * c.k
-					b += float64(src.Pix[off+2]) * c.k
+					s := src.Pix[off : off+3 : off+3]
+					r += float64(s[0]) * c.k
+					g += float64(s[1]) * c.k
+					b += float64(s[2]) * c.k
 				}
 
 				if options.Abs {
@@ -115,10 +116,11 @@ func convolve(img image.Image, kernel []float64, options *ConvolveOptions) *imag
 
 				srcOff := y*src.Stride + x*4
 				dstOff := y*dst.Stride + x*4
-				dst.Pix[dstOff+0] = clamp(r)
-				dst.Pix[dstOff+1] = clamp(g)
-				dst.Pix[dstOff+2] = clamp(b)
-				dst.Pix[dstOff+3] = src.Pix[srcOff+3]
+				d := dst.Pix[dstOff : dstOff+4 : dstOff+4]
+				d[0] = clamp(r)
+				d[1] = clamp(g)
+				d[2] = clamp(b)
+				d[3] = src.Pix[srcOff+3]
 			}
 		}
 	})

vendor/github.com/disintegration/imaging/doc.go

@@ -2,6 +2,6 @@
 Package imaging provides basic image processing functions (resize, rotate, crop, brightness/contrast adjustments, etc.).
 
 All the image processing functions provided by the package accept any image type that implements image.Image interface
-as an input, and return a new image of *image.NRGBA type (32bit RGBA colors, not premultiplied by alpha).
+as an input, and return a new image of *image.NRGBA type (32bit RGBA colors, non-premultiplied alpha).
 */
 package imaging

vendor/github.com/disintegration/imaging/effects.go

@@ -12,7 +12,7 @@ func gaussianBlurKernel(x, sigma float64) float64 {
 // Blur produces a blurred version of the image using a Gaussian function.
 // Sigma parameter must be positive and indicates how much the image will be blurred.
 //
-// Usage example:
+// Example:
 //
 //	dstImage := imaging.Blur(srcImage, 3.5)
 //
@@ -44,7 +44,7 @@ func blurHorizontal(img image.Image, kernel []float64) *image.NRGBA {
 			for i, v := range scanLine {
 				scanLineF[i] = float64(v)
 			}
-			for x, idx := 0, 0; x < src.w; x, idx = x+1, idx+4 {
+			for x := 0; x < src.w; x++ {
 				min := x - radius
 				if min < 0 {
 					min = 0
@@ -53,30 +53,28 @@ func blurHorizontal(img image.Image, kernel []float64) *image.NRGBA {
 				if max > src.w-1 {
 					max = src.w - 1
 				}
-
 				var r, g, b, a, wsum float64
 				for ix := min; ix <= max; ix++ {
 					i := ix * 4
 					weight := kernel[absint(x-ix)]
 					wsum += weight
-					wa := scanLineF[i+3] * weight
-					r += scanLineF[i+0] * wa
-					g += scanLineF[i+1] * wa
-					b += scanLineF[i+2] * wa
+					s := scanLineF[i : i+4 : i+4]
+					wa := s[3] * weight
+					r += s[0] * wa
+					g += s[1] * wa
+					b += s[2] * wa
 					a += wa
 				}
 				if a != 0 {
-					r /= a
-					g /= a
-					b /= a
+					aInv := 1 / a
+					j := y*dst.Stride + x*4
+					d := dst.Pix[j : j+4 : j+4]
+					d[0] = clamp(r * aInv)
+					d[1] = clamp(g * aInv)
+					d[2] = clamp(b * aInv)
+					d[3] = clamp(a / wsum)
 				}
-
-				scanLine[idx+0] = clamp(r)
-				scanLine[idx+1] = clamp(g)
-				scanLine[idx+2] = clamp(b)
-				scanLine[idx+3] = clamp(a / wsum)
 			}
-			copy(dst.Pix[y*dst.Stride:], scanLine)
 		}
 	})
 
@@ -105,29 +103,27 @@ func blurVertical(img image.Image, kernel []float64) *image.NRGBA {
 				if max > src.h-1 {
 					max = src.h - 1
 				}
-
 				var r, g, b, a, wsum float64
 				for iy := min; iy <= max; iy++ {
 					i := iy * 4
 					weight := kernel[absint(y-iy)]
 					wsum += weight
-					wa := scanLineF[i+3] * weight
-					r += scanLineF[i+0] * wa
-					g += scanLineF[i+1] * wa
-					b += scanLineF[i+2] * wa
+					s := scanLineF[i : i+4 : i+4]
+					wa := s[3] * weight
+					r += s[0] * wa
+					g += s[1] * wa
+					b += s[2] * wa
 					a += wa
 				}
 				if a != 0 {
-					r /= a
-					g /= a
-					b /= a
+					aInv := 1 / a
+					j := y*dst.Stride + x*4
+					d := dst.Pix[j : j+4 : j+4]
+					d[0] = clamp(r * aInv)
+					d[1] = clamp(g * aInv)
+					d[2] = clamp(b * aInv)
+					d[3] = clamp(a / wsum)
 				}
-
-				j := y*dst.Stride + x*4
-				dst.Pix[j+0] = clamp(r)
-				dst.Pix[j+1] = clamp(g)
-				dst.Pix[j+2] = clamp(b)
-				dst.Pix[j+3] = clamp(a / wsum)
 			}
 		}
 	})
@@ -138,7 +134,7 @@ func blurVertical(img image.Image, kernel []float64) *image.NRGBA {
 // Sharpen produces a sharpened version of the image.
 // Sigma parameter must be positive and indicates how much the image will be sharpened.
 //
-// Usage example:
+// Example:
 //
 //	dstImage := imaging.Sharpen(srcImage, 3.5)
 //

vendor/github.com/disintegration/imaging/go.mod

@@ -0,0 +1,3 @@
+module github.com/disintegration/imaging
+
+require golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81

vendor/github.com/disintegration/imaging/go.sum

@@ -0,0 +1,2 @@
+golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81 h1:00VmoueYNlNz/aHIilyyQz/MHSqGoWJzpFv/HW8xpzI=
+golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs=

vendor/github.com/disintegration/imaging/histogram.go

@@ -27,9 +27,10 @@ func Histogram(img image.Image) [256]float64 {
 			src.scan(0, y, src.w, y+1, scanLine)
 			i := 0
 			for x := 0; x < src.w; x++ {
-				r := scanLine[i+0]
-				g := scanLine[i+1]
-				b := scanLine[i+2]
+				s := scanLine[i : i+3 : i+3]
+				r := s[0]
+				g := s[1]
+				b := s[2]
 				y := 0.299*float32(r) + 0.587*float32(g) + 0.114*float32(b)
 				tmpHistogram[int(y+0.5)]++
 				tmpTotal++

vendor/github.com/disintegration/imaging/io.go

@@ -18,66 +18,6 @@ import (
 	"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)
@@ -161,6 +101,59 @@ func Open(filename string, opts ...DecodeOption) (image.Image, error) {
 	return Decode(file, opts...)
 }
 
+// Format is an image file format.
+type Format int
+
+// Image file formats.
+const (
+	JPEG Format = iota
+	PNG
+	GIF
+	TIFF
+	BMP
+)
+
+var formatExts = map[string]Format{
+	"jpg":  JPEG,
+	"jpeg": JPEG,
+	"png":  PNG,
+	"gif":  GIF,
+	"tif":  TIFF,
+	"tiff": TIFF,
+	"bmp":  BMP,
+}
+
+var formatNames = map[Format]string{
+	JPEG: "JPEG",
+	PNG:  "PNG",
+	GIF:  "GIF",
+	TIFF: "TIFF",
+	BMP:  "BMP",
+}
+
+func (f Format) String() string {
+	return formatNames[f]
+}
+
+// ErrUnsupportedFormat means the given image format is not supported.
+var ErrUnsupportedFormat = errors.New("imaging: unsupported image format")
+
+// FormatFromExtension parses image format from filename extension:
+// "jpg" (or "jpeg"), "png", "gif", "tif" (or "tiff") and "bmp" are supported.
+func FormatFromExtension(ext string) (Format, error) {
+	if f, ok := formatExts[strings.ToLower(strings.TrimPrefix(ext, "."))]; ok {
+		return f, nil
+	}
+	return -1, ErrUnsupportedFormat
+}
+
+// FormatFromFilename parses image format from filename:
+// "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)
+}
+
 type encodeConfig struct {
 	jpegQuality         int
 	gifNumColors        int
@@ -227,46 +220,37 @@ func Encode(w io.Writer, img image.Image, format Format, opts ...EncodeOption) e
 		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 nrgba, ok := img.(*image.NRGBA); ok && nrgba.Opaque() {
+			rgba := &image.RGBA{
+				Pix:    nrgba.Pix,
+				Stride: nrgba.Stride,
+				Rect:   nrgba.Rect,
 			}
+			return jpeg.Encode(w, rgba, &jpeg.Options{Quality: cfg.jpegQuality})
 		}
-		if rgba != nil {
-			err = jpeg.Encode(w, rgba, &jpeg.Options{Quality: cfg.jpegQuality})
-		} else {
-			err = jpeg.Encode(w, img, &jpeg.Options{Quality: cfg.jpegQuality})
-		}
+		return jpeg.Encode(w, img, &jpeg.Options{Quality: cfg.jpegQuality})
 
 	case PNG:
-		enc := png.Encoder{CompressionLevel: cfg.pngCompressionLevel}
-		err = enc.Encode(w, img)
+		encoder := png.Encoder{CompressionLevel: cfg.pngCompressionLevel}
+		return encoder.Encode(w, img)
 
 	case GIF:
-		err = gif.Encode(w, img, &gif.Options{
+		return 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})
+		return tiff.Encode(w, img, &tiff.Options{Compression: tiff.Deflate, Predictor: true})
 
 	case BMP:
-		err = bmp.Encode(w, img)
-
-	default:
-		err = ErrUnsupportedFormat
+		return bmp.Encode(w, img)
 	}
-	return err
+
+	return ErrUnsupportedFormat
 }
 
 // Save saves the image to file with the specified filename.
@@ -290,15 +274,12 @@ func Save(img image.Image, filename string, opts ...EncodeOption) (err error) {
 	if err != nil {
 		return err
 	}
-
-	defer func() {
-		cerr := file.Close()
-		if err == nil {
-			err = cerr
-		}
-	}()
-
-	return Encode(file, img, f, opts...)
+	err = Encode(file, img, f, opts...)
+	errc := file.Close()
+	if err == nil {
+		err = errc
+	}
+	return err
 }
 
 // orientation is an EXIF flag that specifies the transformation

vendor/github.com/disintegration/imaging/resize.go

@@ -58,10 +58,7 @@ func precomputeWeights(dstSize, srcSize int, filter ResampleFilter) [][]indexWei
 // filter and returns the transformed image. If one of width or height is 0, the image aspect
 // ratio is preserved.
 //
-// Supported resample filters: NearestNeighbor, Box, Linear, Hermite, MitchellNetravali,
-// CatmullRom, BSpline, Gaussian, Lanczos, Hann, Hamming, Blackman, Bartlett, Welch, Cosine.
-//
-// Usage example:
+// Example:
 //
 //	dstImage := imaging.Resize(srcImage, 800, 600, imaging.Lanczos)
 //
@@ -116,23 +113,25 @@ func resizeHorizontal(img image.Image, width int, filter ResampleFilter) *image.
 		for y := range ys {
 			src.scan(0, y, src.w, y+1, scanLine)
 			j0 := y * dst.Stride
-			for x := 0; x < width; x++ {
+			for x := range weights {
 				var r, g, b, a float64
 				for _, w := range weights[x] {
 					i := w.index * 4
-					aw := float64(scanLine[i+3]) * w.weight
-					r += float64(scanLine[i+0]) * aw
-					g += float64(scanLine[i+1]) * aw
-					b += float64(scanLine[i+2]) * aw
+					s := scanLine[i : i+4 : i+4]
+					aw := float64(s[3]) * w.weight
+					r += float64(s[0]) * aw
+					g += float64(s[1]) * aw
+					b += float64(s[2]) * aw
 					a += aw
 				}
 				if a != 0 {
 					aInv := 1 / a
 					j := j0 + x*4
-					dst.Pix[j+0] = clamp(r * aInv)
-					dst.Pix[j+1] = clamp(g * aInv)
-					dst.Pix[j+2] = clamp(b * aInv)
-					dst.Pix[j+3] = clamp(a)
+					d := dst.Pix[j : j+4 : j+4]
+					d[0] = clamp(r * aInv)
+					d[1] = clamp(g * aInv)
+					d[2] = clamp(b * aInv)
+					d[3] = clamp(a)
 				}
 			}
 		}
@@ -148,23 +147,25 @@ func resizeVertical(img image.Image, height int, filter ResampleFilter) *image.N
 		scanLine := make([]uint8, src.h*4)
 		for x := range xs {
 			src.scan(x, 0, x+1, src.h, scanLine)
-			for y := 0; y < height; y++ {
+			for y := range weights {
 				var r, g, b, a float64
 				for _, w := range weights[y] {
 					i := w.index * 4
-					aw := float64(scanLine[i+3]) * w.weight
-					r += float64(scanLine[i+0]) * aw
-					g += float64(scanLine[i+1]) * aw
-					b += float64(scanLine[i+2]) * aw
+					s := scanLine[i : i+4 : i+4]
+					aw := float64(s[3]) * w.weight
+					r += float64(s[0]) * aw
+					g += float64(s[1]) * aw
+					b += float64(s[2]) * aw
 					a += aw
 				}
 				if a != 0 {
 					aInv := 1 / a
 					j := y*dst.Stride + x*4
-					dst.Pix[j+0] = clamp(r * aInv)
-					dst.Pix[j+1] = clamp(g * aInv)
-					dst.Pix[j+2] = clamp(b * aInv)
-					dst.Pix[j+3] = clamp(a)
+					d := dst.Pix[j : j+4 : j+4]
+					d[0] = clamp(r * aInv)
+					d[1] = clamp(g * aInv)
+					d[2] = clamp(b * aInv)
+					d[3] = clamp(a)
 				}
 			}
 		}
@@ -214,10 +215,7 @@ func resizeNearest(img image.Image, width, height int) *image.NRGBA {
 // Fit scales down the image using the specified resample filter to fit the specified
 // maximum width and height and returns the transformed image.
 //
-// Supported resample filters: NearestNeighbor, Box, Linear, Hermite, MitchellNetravali,
-// CatmullRom, BSpline, Gaussian, Lanczos, Hann, Hamming, Blackman, Bartlett, Welch, Cosine.
-//
-// Usage example:
+// Example:
 //
 //	dstImage := imaging.Fit(srcImage, 800, 600, imaging.Lanczos)
 //
@@ -255,21 +253,17 @@ func Fit(img image.Image, width, height int, filter ResampleFilter) *image.NRGBA
 	return Resize(img, newW, newH, filter)
 }
 
-// Fill scales the image to the smallest possible size that will cover the specified dimensions,
-// crops the resized image to the specified dimensions using the given anchor point and returns
-// the transformed image.
+// Fill creates an image with the specified dimensions and fills it with the scaled source image.
+// To achieve the correct aspect ratio without stretching, the source image will be cropped.
 //
-// Supported resample filters: NearestNeighbor, Box, Linear, Hermite, MitchellNetravali,
-// CatmullRom, BSpline, Gaussian, Lanczos, Hann, Hamming, Blackman, Bartlett, Welch, Cosine.
-//
-// Usage example:
+// Example:
 //
 //	dstImage := imaging.Fill(srcImage, 800, 600, imaging.Center, imaging.Lanczos)
 //
 func Fill(img image.Image, width, height int, anchor Anchor, filter ResampleFilter) *image.NRGBA {
-	minW, minH := width, height
+	dstW, dstH := width, height
 
-	if minW <= 0 || minH <= 0 {
+	if dstW <= 0 || dstH <= 0 {
 		return &image.NRGBA{}
 	}
 
@@ -281,30 +275,67 @@ func Fill(img image.Image, width, height int, anchor Anchor, filter ResampleFilt
 		return &image.NRGBA{}
 	}
 
-	if srcW == minW && srcH == minH {
+	if srcW == dstW && srcH == dstH {
 		return Clone(img)
 	}
 
+	if srcW >= 100 && srcH >= 100 {
+		return cropAndResize(img, dstW, dstH, anchor, filter)
+	}
+	return resizeAndCrop(img, dstW, dstH, anchor, filter)
+}
+
+// cropAndResize crops the image to the smallest possible size that has the required aspect ratio using
+// the given anchor point, then scales it to the specified dimensions and returns the transformed image.
+//
+// This is generally faster than resizing first, but may result in inaccuracies when used on small source images.
+func cropAndResize(img image.Image, width, height int, anchor Anchor, filter ResampleFilter) *image.NRGBA {
+	dstW, dstH := width, height
+
+	srcBounds := img.Bounds()
+	srcW := srcBounds.Dx()
+	srcH := srcBounds.Dy()
 	srcAspectRatio := float64(srcW) / float64(srcH)
-	minAspectRatio := float64(minW) / float64(minH)
+	dstAspectRatio := float64(dstW) / float64(dstH)
 
 	var tmp *image.NRGBA
-	if srcAspectRatio < minAspectRatio {
-		tmp = Resize(img, minW, 0, filter)
+	if srcAspectRatio < dstAspectRatio {
+		cropH := float64(srcW) * float64(dstH) / float64(dstW)
+		tmp = CropAnchor(img, srcW, int(math.Max(1, cropH)+0.5), anchor)
 	} else {
-		tmp = Resize(img, 0, minH, filter)
+		cropW := float64(srcH) * float64(dstW) / float64(dstH)
+		tmp = CropAnchor(img, int(math.Max(1, cropW)+0.5), srcH, anchor)
 	}
 
-	return CropAnchor(tmp, minW, minH, anchor)
+	return Resize(tmp, dstW, dstH, filter)
+}
+
+// resizeAndCrop resizes the image to the smallest possible size that will cover the specified dimensions,
+// crops the resized image to the specified dimensions using the given anchor point and returns
+// the transformed image.
+func resizeAndCrop(img image.Image, width, height int, anchor Anchor, filter ResampleFilter) *image.NRGBA {
+	dstW, dstH := width, height
+
+	srcBounds := img.Bounds()
+	srcW := srcBounds.Dx()
+	srcH := srcBounds.Dy()
+	srcAspectRatio := float64(srcW) / float64(srcH)
+	dstAspectRatio := float64(dstW) / float64(dstH)
+
+	var tmp *image.NRGBA
+	if srcAspectRatio < dstAspectRatio {
+		tmp = Resize(img, dstW, 0, filter)
+	} else {
+		tmp = Resize(img, 0, dstH, filter)
+	}
+
+	return CropAnchor(tmp, dstW, dstH, anchor)
 }
 
 // Thumbnail scales the image up or down using the specified resample filter, crops it
 // to the specified width and hight and returns the transformed image.
 //
-// Supported resample filters: NearestNeighbor, Box, Linear, Hermite, MitchellNetravali,
-// CatmullRom, BSpline, Gaussian, Lanczos, Hann, Hamming, Blackman, Bartlett, Welch, Cosine.
-//
-// Usage example:
+// Example:
 //
 //	dstImage := imaging.Thumbnail(srcImage, 100, 100, imaging.Lanczos)
 //
@@ -312,29 +343,21 @@ func Thumbnail(img image.Image, width, height int, filter ResampleFilter) *image
 	return Fill(img, width, height, Center, filter)
 }
 
-// ResampleFilter is a resampling filter struct. It can be used to define custom filters.
-//
-// Supported resample filters: NearestNeighbor, Box, Linear, Hermite, MitchellNetravali,
-// CatmullRom, BSpline, Gaussian, Lanczos, Hann, Hamming, Blackman, Bartlett, Welch, Cosine.
+// ResampleFilter specifies a resampling filter to be used for image resizing.
 //
 //	General filter recommendations:
 //
 //	- Lanczos
-//		High-quality resampling filter for photographic images yielding sharp results.
-//		It's slower than cubic filters (see below).
+//		A high-quality resampling filter for photographic images yielding sharp results.
 //
 //	- CatmullRom
-//		A sharp cubic filter. It's a good filter for both upscaling and downscaling if sharp results are needed.
+//		A sharp cubic filter that is faster than Lanczos filter while providing similar results.
 //
 //	- MitchellNetravali
-//		A high quality cubic filter that produces smoother results with less ringing artifacts than CatmullRom.
-//
-//	- BSpline
-//		A good filter if a very smooth output is needed.
+//		A cubic filter that produces smoother results with less ringing artifacts than CatmullRom.
 //
 //	- Linear
-//		Bilinear interpolation filter, produces reasonably good, smooth output.
-//		It's faster than cubic filters.
+//		Bilinear resampling filter, produces a smooth output. Faster than cubic filters.
 //
 //	- Box
 //		Simple and fast averaging filter appropriate for downscaling.
@@ -369,7 +392,7 @@ var CatmullRom ResampleFilter
 // BSpline is a smooth cubic filter (BC-spline; B=1; C=0).
 var BSpline ResampleFilter
 
-// Gaussian is a Gaussian blurring Filter.
+// Gaussian is a Gaussian blurring filter.
 var Gaussian ResampleFilter
 
 // Bartlett is a Bartlett-windowed sinc filter (3 lobes).

vendor/github.com/disintegration/imaging/scanner.go

@@ -33,10 +33,23 @@ func (s *scanner) scan(x1, y1, x2, y2 int, dst []uint8) {
 		size := (x2 - x1) * 4
 		j := 0
 		i := y1*img.Stride + x1*4
-		for y := y1; y < y2; y++ {
-			copy(dst[j:j+size], img.Pix[i:i+size])
-			j += size
-			i += img.Stride
+		if size == 4 {
+			for y := y1; y < y2; y++ {
+				d := dst[j : j+4 : j+4]
+				s := img.Pix[i : i+4 : i+4]
+				d[0] = s[0]
+				d[1] = s[1]
+				d[2] = s[2]
+				d[3] = s[3]
+				j += size
+				i += img.Stride
+			}
+		} else {
+			for y := y1; y < y2; y++ {
+				copy(dst[j:j+size], img.Pix[i:i+size])
+				j += size
+				i += img.Stride
+			}
 		}
 
 	case *image.NRGBA64:
@@ -44,10 +57,12 @@ func (s *scanner) scan(x1, y1, x2, y2 int, dst []uint8) {
 		for y := y1; y < y2; y++ {
 			i := y*img.Stride + x1*8
 			for x := x1; x < x2; x++ {
-				dst[j+0] = img.Pix[i+0]
-				dst[j+1] = img.Pix[i+2]
-				dst[j+2] = img.Pix[i+4]
-				dst[j+3] = img.Pix[i+6]
+				s := img.Pix[i : i+8 : i+8]
+				d := dst[j : j+4 : j+4]
+				d[0] = s[0]
+				d[1] = s[2]
+				d[2] = s[4]
+				d[3] = s[6]
 				j += 4
 				i += 8
 			}
@@ -58,26 +73,31 @@ func (s *scanner) scan(x1, y1, x2, y2 int, dst []uint8) {
 		for y := y1; y < y2; y++ {
 			i := y*img.Stride + x1*4
 			for x := x1; x < x2; x++ {
+				d := dst[j : j+4 : j+4]
 				a := img.Pix[i+3]
 				switch a {
 				case 0:
-					dst[j+0] = 0
-					dst[j+1] = 0
-					dst[j+2] = 0
+					d[0] = 0
+					d[1] = 0
+					d[2] = 0
+					d[3] = a
 				case 0xff:
-					dst[j+0] = img.Pix[i+0]
-					dst[j+1] = img.Pix[i+1]
-					dst[j+2] = img.Pix[i+2]
+					s := img.Pix[i : i+4 : i+4]
+					d[0] = s[0]
+					d[1] = s[1]
+					d[2] = s[2]
+					d[3] = a
 				default:
-					r16 := uint16(img.Pix[i+0])
-					g16 := uint16(img.Pix[i+1])
-					b16 := uint16(img.Pix[i+2])
+					s := img.Pix[i : i+4 : i+4]
+					r16 := uint16(s[0])
+					g16 := uint16(s[1])
+					b16 := uint16(s[2])
 					a16 := uint16(a)
-					dst[j+0] = uint8(r16 * 0xff / a16)
-					dst[j+1] = uint8(g16 * 0xff / a16)
-					dst[j+2] = uint8(b16 * 0xff / a16)
+					d[0] = uint8(r16 * 0xff / a16)
+					d[1] = uint8(g16 * 0xff / a16)
+					d[2] = uint8(b16 * 0xff / a16)
+					d[3] = a
 				}
-				dst[j+3] = a
 				j += 4
 				i += 4
 			}
@@ -88,26 +108,28 @@ func (s *scanner) scan(x1, y1, x2, y2 int, dst []uint8) {
 		for y := y1; y < y2; y++ {
 			i := y*img.Stride + x1*8
 			for x := x1; x < x2; x++ {
-				a := img.Pix[i+6]
+				s := img.Pix[i : i+8 : i+8]
+				d := dst[j : j+4 : j+4]
+				a := s[6]
 				switch a {
 				case 0:
-					dst[j+0] = 0
-					dst[j+1] = 0
-					dst[j+2] = 0
+					d[0] = 0
+					d[1] = 0
+					d[2] = 0
 				case 0xff:
-					dst[j+0] = img.Pix[i+0]
-					dst[j+1] = img.Pix[i+2]
-					dst[j+2] = img.Pix[i+4]
+					d[0] = s[0]
+					d[1] = s[2]
+					d[2] = s[4]
 				default:
-					r32 := uint32(img.Pix[i+0])<<8 | uint32(img.Pix[i+1])
-					g32 := uint32(img.Pix[i+2])<<8 | uint32(img.Pix[i+3])
-					b32 := uint32(img.Pix[i+4])<<8 | uint32(img.Pix[i+5])
-					a32 := uint32(img.Pix[i+6])<<8 | uint32(img.Pix[i+7])
-					dst[j+0] = uint8((r32 * 0xffff / a32) >> 8)
-					dst[j+1] = uint8((g32 * 0xffff / a32) >> 8)
-					dst[j+2] = uint8((b32 * 0xffff / a32) >> 8)
+					r32 := uint32(s[0])<<8 | uint32(s[1])
+					g32 := uint32(s[2])<<8 | uint32(s[3])
+					b32 := uint32(s[4])<<8 | uint32(s[5])
+					a32 := uint32(s[6])<<8 | uint32(s[7])
+					d[0] = uint8((r32 * 0xffff / a32) >> 8)
+					d[1] = uint8((g32 * 0xffff / a32) >> 8)
+					d[2] = uint8((b32 * 0xffff / a32) >> 8)
 				}
-				dst[j+3] = a
+				d[3] = a
 				j += 4
 				i += 8
 			}
@@ -119,10 +141,11 @@ func (s *scanner) scan(x1, y1, x2, y2 int, dst []uint8) {
 			i := y*img.Stride + x1
 			for x := x1; x < x2; x++ {
 				c := img.Pix[i]
-				dst[j+0] = c
-				dst[j+1] = c
-				dst[j+2] = c
-				dst[j+3] = 0xff
+				d := dst[j : j+4 : j+4]
+				d[0] = c
+				d[1] = c
+				d[2] = c
+				d[3] = 0xff
 				j += 4
 				i++
 			}
@@ -134,10 +157,11 @@ func (s *scanner) scan(x1, y1, x2, y2 int, dst []uint8) {
 			i := y*img.Stride + x1*2
 			for x := x1; x < x2; x++ {
 				c := img.Pix[i]
-				dst[j+0] = c
-				dst[j+1] = c
-				dst[j+2] = c
-				dst[j+3] = 0xff
+				d := dst[j : j+4 : j+4]
+				d[0] = c
+				d[1] = c
+				d[2] = c
+				d[3] = 0xff
 				j += 4
 				i += 2
 			}
@@ -149,52 +173,61 @@ func (s *scanner) scan(x1, y1, x2, y2 int, dst []uint8) {
 		x2 += img.Rect.Min.X
 		y1 += img.Rect.Min.Y
 		y2 += img.Rect.Min.Y
+
+		hy := img.Rect.Min.Y / 2
+		hx := img.Rect.Min.X / 2
 		for y := y1; y < y2; y++ {
 			iy := (y-img.Rect.Min.Y)*img.YStride + (x1 - img.Rect.Min.X)
+
+			var yBase int
+			switch img.SubsampleRatio {
+			case image.YCbCrSubsampleRatio444, image.YCbCrSubsampleRatio422:
+				yBase = (y - img.Rect.Min.Y) * img.CStride
+			case image.YCbCrSubsampleRatio420, image.YCbCrSubsampleRatio440:
+				yBase = (y/2 - hy) * img.CStride
+			}
+
 			for x := x1; x < x2; x++ {
 				var ic int
 				switch img.SubsampleRatio {
-				case image.YCbCrSubsampleRatio444:
-					ic = (y-img.Rect.Min.Y)*img.CStride + (x - img.Rect.Min.X)
-				case image.YCbCrSubsampleRatio422:
-					ic = (y-img.Rect.Min.Y)*img.CStride + (x/2 - img.Rect.Min.X/2)
-				case image.YCbCrSubsampleRatio420:
-					ic = (y/2-img.Rect.Min.Y/2)*img.CStride + (x/2 - img.Rect.Min.X/2)
-				case image.YCbCrSubsampleRatio440:
-					ic = (y/2-img.Rect.Min.Y/2)*img.CStride + (x - img.Rect.Min.X)
+				case image.YCbCrSubsampleRatio444, image.YCbCrSubsampleRatio440:
+					ic = yBase + (x - img.Rect.Min.X)
+				case image.YCbCrSubsampleRatio422, image.YCbCrSubsampleRatio420:
+					ic = yBase + (x/2 - hx)
 				default:
 					ic = img.COffset(x, y)
 				}
 
-				yy := int(img.Y[iy])
-				cb := int(img.Cb[ic]) - 128
-				cr := int(img.Cr[ic]) - 128
+				yy1 := int32(img.Y[iy]) * 0x10101
+				cb1 := int32(img.Cb[ic]) - 128
+				cr1 := int32(img.Cr[ic]) - 128
 
-				r := (yy<<16 + 91881*cr + 1<<15) >> 16
-				if r > 0xff {
-					r = 0xff
-				} else if r < 0 {
-					r = 0
+				r := yy1 + 91881*cr1
+				if uint32(r)&0xff000000 == 0 {
+					r >>= 16
+				} else {
+					r = ^(r >> 31)
 				}
 
-				g := (yy<<16 - 22554*cb - 46802*cr + 1<<15) >> 16
-				if g > 0xff {
-					g = 0xff
-				} else if g < 0 {
-					g = 0
+				g := yy1 - 22554*cb1 - 46802*cr1
+				if uint32(g)&0xff000000 == 0 {
+					g >>= 16
+				} else {
+					g = ^(g >> 31)
 				}
 
-				b := (yy<<16 + 116130*cb + 1<<15) >> 16
-				if b > 0xff {
-					b = 0xff
-				} else if b < 0 {
-					b = 0
+				b := yy1 + 116130*cb1
+				if uint32(b)&0xff000000 == 0 {
+					b >>= 16
+				} else {
+					b = ^(b >> 31)
 				}
 
-				dst[j+0] = uint8(r)
-				dst[j+1] = uint8(g)
-				dst[j+2] = uint8(b)
-				dst[j+3] = 0xff
+				d := dst[j : j+4 : j+4]
+				d[0] = uint8(r)
+				d[1] = uint8(g)
+				d[2] = uint8(b)
+				d[3] = 0xff
 
 				iy++
 				j += 4
@@ -207,10 +240,11 @@ func (s *scanner) scan(x1, y1, x2, y2 int, dst []uint8) {
 			i := y*img.Stride + x1
 			for x := x1; x < x2; x++ {
 				c := s.palette[img.Pix[i]]
-				dst[j+0] = c.R
-				dst[j+1] = c.G
-				dst[j+2] = c.B
-				dst[j+3] = c.A
+				d := dst[j : j+4 : j+4]
+				d[0] = c.R
+				d[1] = c.G
+				d[2] = c.B
+				d[3] = c.A
 				j += 4
 				i++
 			}
@@ -226,22 +260,23 @@ func (s *scanner) scan(x1, y1, x2, y2 int, dst []uint8) {
 		for y := y1; y < y2; y++ {
 			for x := x1; x < x2; x++ {
 				r16, g16, b16, a16 := s.image.At(x, y).RGBA()
+				d := dst[j : j+4 : j+4]
 				switch a16 {
 				case 0xffff:
-					dst[j+0] = uint8(r16 >> 8)
-					dst[j+1] = uint8(g16 >> 8)
-					dst[j+2] = uint8(b16 >> 8)
-					dst[j+3] = 0xff
+					d[0] = uint8(r16 >> 8)
+					d[1] = uint8(g16 >> 8)
+					d[2] = uint8(b16 >> 8)
+					d[3] = 0xff
 				case 0:
-					dst[j+0] = 0
-					dst[j+1] = 0
-					dst[j+2] = 0
-					dst[j+3] = 0
+					d[0] = 0
+					d[1] = 0
+					d[2] = 0
+					d[3] = 0
 				default:
-					dst[j+0] = uint8(((r16 * 0xffff) / a16) >> 8)
-					dst[j+1] = uint8(((g16 * 0xffff) / a16) >> 8)
-					dst[j+2] = uint8(((b16 * 0xffff) / a16) >> 8)
-					dst[j+3] = uint8(a16 >> 8)
+					d[0] = uint8(((r16 * 0xffff) / a16) >> 8)
+					d[1] = uint8(((g16 * 0xffff) / a16) >> 8)
+					d[2] = uint8(((b16 * 0xffff) / a16) >> 8)
+					d[3] = uint8(a16 >> 8)
 				}
 				j += 4
 			}

vendor/github.com/disintegration/imaging/tools.go

@@ -169,7 +169,7 @@ func PasteCenter(background, img image.Image) *image.NRGBA {
 // and returns the combined image. Opacity parameter is the opacity of the img
 // image layer, used to compose the images, it must be from 0.0 to 1.0.
 //
-// Usage examples:
+// Examples:
 //
 //	// Draw spriteImage over backgroundImage at the given position (x=50, y=50).
 //	dstImage := imaging.Overlay(backgroundImage, spriteImage, image.Pt(50, 50), 1.0)
@@ -198,15 +198,17 @@ func Overlay(background, img image.Image, pos image.Point, opacity float64) *ima
 			i := y*dst.Stride + interRect.Min.X*4
 			j := 0
 			for x := interRect.Min.X; x < interRect.Max.X; x++ {
-				r1 := float64(dst.Pix[i+0])
-				g1 := float64(dst.Pix[i+1])
-				b1 := float64(dst.Pix[i+2])
-				a1 := float64(dst.Pix[i+3])
+				d := dst.Pix[i : i+4 : i+4]
+				r1 := float64(d[0])
+				g1 := float64(d[1])
+				b1 := float64(d[2])
+				a1 := float64(d[3])
 
-				r2 := float64(scanLine[j+0])
-				g2 := float64(scanLine[j+1])
-				b2 := float64(scanLine[j+2])
-				a2 := float64(scanLine[j+3])
+				s := scanLine[j : j+4 : j+4]
+				r2 := float64(s[0])
+				g2 := float64(s[1])
+				b2 := float64(s[2])
+				a2 := float64(s[3])
 
 				coef2 := opacity * a2 / 255
 				coef1 := (1 - coef2) * a1 / 255
@@ -214,10 +216,10 @@ func Overlay(background, img image.Image, pos image.Point, opacity float64) *ima
 				coef1 /= coefSum
 				coef2 /= coefSum
 
-				dst.Pix[i+0] = uint8(r1*coef1 + r2*coef2)
-				dst.Pix[i+1] = uint8(g1*coef1 + g2*coef2)
-				dst.Pix[i+2] = uint8(b1*coef1 + b2*coef2)
-				dst.Pix[i+3] = uint8(math.Min(a1+a2*opacity*(255-a1)/255, 255))
+				d[0] = uint8(r1*coef1 + r2*coef2)
+				d[1] = uint8(g1*coef1 + g2*coef2)
+				d[2] = uint8(b1*coef1 + b2*coef2)
+				d[3] = uint8(math.Min(a1+a2*opacity*(255-a1)/255, 255))
 
 				i += 4
 				j += 4

vendor/github.com/disintegration/imaging/transform.go

@@ -209,63 +209,60 @@ func rotatedSize(w, h int, angle float64) (int, int) {
 }
 
 func interpolatePoint(dst *image.NRGBA, dstX, dstY int, src *image.NRGBA, xf, yf float64, bgColor color.NRGBA) {
-	dstIndex := dstY*dst.Stride + dstX*4
+	j := dstY*dst.Stride + dstX*4
+	d := dst.Pix[j : j+4 : j+4]
 
 	x0 := int(math.Floor(xf))
 	y0 := int(math.Floor(yf))
 	bounds := src.Bounds()
 	if !image.Pt(x0, y0).In(image.Rect(bounds.Min.X-1, bounds.Min.Y-1, bounds.Max.X, bounds.Max.Y)) {
-		dst.Pix[dstIndex+0] = bgColor.R
-		dst.Pix[dstIndex+1] = bgColor.G
-		dst.Pix[dstIndex+2] = bgColor.B
-		dst.Pix[dstIndex+3] = bgColor.A
+		d[0] = bgColor.R
+		d[1] = bgColor.G
+		d[2] = bgColor.B
+		d[3] = bgColor.A
 		return
 	}
 
 	xq := xf - float64(x0)
 	yq := yf - float64(y0)
-
-	var pxs [4]color.NRGBA
-	var cfs [4]float64
-
-	for i := 0; i < 2; i++ {
-		for j := 0; j < 2; j++ {
-			k := i*2 + j
-			pt := image.Pt(x0+j, y0+i)
-			if pt.In(bounds) {
-				l := pt.Y*src.Stride + pt.X*4
-				pxs[k].R = src.Pix[l+0]
-				pxs[k].G = src.Pix[l+1]
-				pxs[k].B = src.Pix[l+2]
-				pxs[k].A = src.Pix[l+3]
-			} else {
-				pxs[k] = bgColor
-			}
-		}
+	points := [4]image.Point{
+		{x0, y0},
+		{x0 + 1, y0},
+		{x0, y0 + 1},
+		{x0 + 1, y0 + 1},
+	}
+	weights := [4]float64{
+		(1 - xq) * (1 - yq),
+		xq * (1 - yq),
+		(1 - xq) * yq,
+		xq * yq,
 	}
-
-	cfs[0] = (1 - xq) * (1 - yq)
-	cfs[1] = xq * (1 - yq)
-	cfs[2] = (1 - xq) * yq
-	cfs[3] = xq * yq
 
 	var r, g, b, a float64
-	for i := range pxs {
-		wa := float64(pxs[i].A) * cfs[i]
-		r += float64(pxs[i].R) * wa
-		g += float64(pxs[i].G) * wa
-		b += float64(pxs[i].B) * wa
-		a += wa
+	for i := 0; i < 4; i++ {
+		p := points[i]
+		w := weights[i]
+		if p.In(bounds) {
+			i := p.Y*src.Stride + p.X*4
+			s := src.Pix[i : i+4 : i+4]
+			wa := float64(s[3]) * w
+			r += float64(s[0]) * wa
+			g += float64(s[1]) * wa
+			b += float64(s[2]) * wa
+			a += wa
+		} else {
+			wa := float64(bgColor.A) * w
+			r += float64(bgColor.R) * wa
+			g += float64(bgColor.G) * wa
+			b += float64(bgColor.B) * wa
+			a += wa
+		}
 	}
-
 	if a != 0 {
-		r /= a
-		g /= a
-		b /= a
+		aInv := 1 / a
+		d[0] = clamp(r * aInv)
+		d[1] = clamp(g * aInv)
+		d[2] = clamp(b * aInv)
+		d[3] = clamp(a)
 	}
-
-	dst.Pix[dstIndex+0] = clamp(r)
-	dst.Pix[dstIndex+1] = clamp(g)
-	dst.Pix[dstIndex+2] = clamp(b)
-	dst.Pix[dstIndex+3] = clamp(a)
 }

vendor/github.com/disintegration/imaging/utils.go

@@ -2,6 +2,7 @@ package imaging
 
 import (
 	"image"
+	"math"
 	"runtime"
 	"sync"
 )
@@ -62,10 +63,12 @@ func reverse(pix []uint8) {
 	i := 0
 	j := len(pix) - 4
 	for i < j {
-		pix[i+0], pix[j+0] = pix[j+0], pix[i+0]
-		pix[i+1], pix[j+1] = pix[j+1], pix[i+1]
-		pix[i+2], pix[j+2] = pix[j+2], pix[i+2]
-		pix[i+3], pix[j+3] = pix[j+3], pix[i+3]
+		pi := pix[i : i+4 : i+4]
+		pj := pix[j : j+4 : j+4]
+		pi[0], pj[0] = pj[0], pi[0]
+		pi[1], pj[1] = pj[1], pi[1]
+		pi[2], pj[2] = pj[2], pi[2]
+		pi[3], pj[3] = pj[3], pi[3]
 		i += 4
 		j -= 4
 	}
@@ -81,3 +84,84 @@ func toNRGBA(img image.Image) *image.NRGBA {
 	}
 	return Clone(img)
 }
+
+// rgbToHSL converts a color from RGB to HSL.
+func rgbToHSL(r, g, b uint8) (float64, float64, float64) {
+	rr := float64(r) / 255
+	gg := float64(g) / 255
+	bb := float64(b) / 255
+
+	max := math.Max(rr, math.Max(gg, bb))
+	min := math.Min(rr, math.Min(gg, bb))
+
+	l := (max + min) / 2
+
+	if max == min {
+		return 0, 0, l
+	}
+
+	var h, s float64
+	d := max - min
+	if l > 0.5 {
+		s = d / (2 - max - min)
+	} else {
+		s = d / (max + min)
+	}
+
+	switch max {
+	case rr:
+		h = (gg - bb) / d
+		if g < b {
+			h += 6
+		}
+	case gg:
+		h = (bb-rr)/d + 2
+	case bb:
+		h = (rr-gg)/d + 4
+	}
+	h /= 6
+
+	return h, s, l
+}
+
+// hslToRGB converts a color from HSL to RGB.
+func hslToRGB(h, s, l float64) (uint8, uint8, uint8) {
+	var r, g, b float64
+	if s == 0 {
+		v := clamp(l * 255)
+		return v, v, v
+	}
+
+	var q float64
+	if l < 0.5 {
+		q = l * (1 + s)
+	} else {
+		q = l + s - l*s
+	}
+	p := 2*l - q
+
+	r = hueToRGB(p, q, h+1/3.0)
+	g = hueToRGB(p, q, h)
+	b = hueToRGB(p, q, h-1/3.0)
+
+	return clamp(r * 255), clamp(g * 255), clamp(b * 255)
+}
+
+func hueToRGB(p, q, t float64) float64 {
+	if t < 0 {
+		t++
+	}
+	if t > 1 {
+		t--
+	}
+	if t < 1/6.0 {
+		return p + (q-p)*6*t
+	}
+	if t < 1/2.0 {
+		return q
+	}
+	if t < 2/3.0 {
+		return p + (q-p)*(2/3.0-t)*6
+	}
+	return p
+}