Fix Avatar Resize (resize algo NearestNeighbor -> Bilinear) (#12745) (#12750)

* Update Vendor github.com/nfnt/resize

* switch resize algo NearestNeighbor -> Bilinear

diff --git a/go.mod b/go.mod
index bcb2d87ad22d6dcc0f969f4b9d4a12f9c4833565..2b436800990f57e2da435d68b56ded1fa7a7f61f 100644 (file)
--- a/go.mod
+++ b/go.mod
@@ -75,7 +75,7 @@ require (
        github.com/microcosm-cc/bluemonday v1.0.3-0.20191119130333-0a75d7616912
        github.com/mitchellh/go-homedir v1.1.0
        github.com/msteinert/pam v0.0.0-20151204160544-02ccfbfaf0cc
-       github.com/nfnt/resize v0.0.0-20160724205520-891127d8d1b5
+       github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
        github.com/niklasfasching/go-org v0.1.9
        github.com/oliamb/cutter v0.2.2
        github.com/olivere/elastic/v7 v7.0.9

diff --git a/go.sum b/go.sum
index e5f538ab5fe20687bf04db1b15649d3a781b672d..99f395acd83b060cb5021228cd59a9d0ff69b41d 100644 (file)
--- a/go.sum
+++ b/go.sum
@@ -483,8 +483,8 @@ github.com/mschoch/smat v0.2.0/go.mod h1:kc9mz7DoBKqDyiRL7VZN8KvXQMWeTaVnttLRXOl
 github.com/msteinert/pam v0.0.0-20151204160544-02ccfbfaf0cc h1:z1PgdCCmYYVL0BoJTUgmAq1p7ca8fzYIPsNyfsN3xAU=
 github.com/msteinert/pam v0.0.0-20151204160544-02ccfbfaf0cc/go.mod h1:np1wUFZ6tyoke22qDJZY40URn9Ae51gX7ljIWXN5TJs=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/nfnt/resize v0.0.0-20160724205520-891127d8d1b5 h1:BvoENQQU+fZ9uukda/RzCAL/191HHwJA5b13R6diVlY=
-github.com/nfnt/resize v0.0.0-20160724205520-891127d8d1b5/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
+github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ=
+github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
 github.com/niklasfasching/go-org v0.1.9 h1:Toz8WMIt+qJb52uYEk1YD/muLuOOmRt1CfkV+bKVMkI=

diff --git a/modules/avatar/avatar.go b/modules/avatar/avatar.go
index cf3da6df5ed9d64fa891af7599cdf8106c54b515..f4c0655fa9762b3ba5a415587bf6e05ebe9da57b 100644 (file)
--- a/modules/avatar/avatar.go
+++ b/modules/avatar/avatar.go
@@ -89,6 +89,6 @@ func Prepare(data []byte) (*image.Image, error) {
                }
        }
 
-       img = resize.Resize(AvatarSize, AvatarSize, img, resize.NearestNeighbor)
+       img = resize.Resize(AvatarSize, AvatarSize, img, resize.Bilinear)
        return &img, nil
 }

diff --git a/vendor/github.com/nfnt/resize/.travis.yml b/vendor/github.com/nfnt/resize/.travis.yml
index 57bd4a76e87596f02bb844ba613d3bbfa479d408..5ff08e7e4e3a79182942ee2a9e5842105f51101a 100644 (file)
--- a/vendor/github.com/nfnt/resize/.travis.yml
+++ b/vendor/github.com/nfnt/resize/.travis.yml
@@ -1,7 +1,7 @@
 language: go
 
 go:
-  - 1.1
-  - 1.2
-  - 1.3
-  - tip
+  - "1.x"
+  - "1.1"
+  - "1.4"
+  - "1.10"

diff --git a/vendor/github.com/nfnt/resize/README.md b/vendor/github.com/nfnt/resize/README.md
index 2aefa75c944303f25c4977eb359c5a2914a3b76b..372777d2ebd53fceb2b63358f1f16dfa1ed92312 100644 (file)
--- a/vendor/github.com/nfnt/resize/README.md
+++ b/vendor/github.com/nfnt/resize/README.md
@@ -1,3 +1,5 @@
+# This package is no longer being updated! Please look for alternatives if that bothers you.
+
 Resize
 ======
 

diff --git a/vendor/github.com/nfnt/resize/resize.go b/vendor/github.com/nfnt/resize/resize.go
index 57bd1fcd0386397aeba94b49bc04348de4f15f5e..0d7fbf69a943fb0701c195f36b35569439cf5ca7 100644 (file)
--- a/vendor/github.com/nfnt/resize/resize.go
+++ b/vendor/github.com/nfnt/resize/resize.go
@@ -78,6 +78,7 @@ var blur = 1.0
 // If one of the parameters width or height is set to 0, its size will be calculated so that
 // the aspect ratio is that of the originating image.
 // The resizing algorithm uses channels for parallel computation.
+// If the input image has width or height of 0, it is returned unchanged.
 func Resize(width, height uint, img image.Image, interp InterpolationFunction) image.Image {
        scaleX, scaleY := calcFactors(width, height, float64(img.Bounds().Dx()), float64(img.Bounds().Dy()))
        if width == 0 {
@@ -92,6 +93,11 @@ func Resize(width, height uint, img image.Image, interp InterpolationFunction) i
                return img
        }
 
+       // Input image has no pixels
+       if img.Bounds().Dx() <= 0 || img.Bounds().Dy() <= 0 {
+               return img
+       }
+
        if interp == NearestNeighbor {
                return resizeNearest(width, height, scaleX, scaleY, img, interp)
        }

diff --git a/vendor/github.com/nfnt/resize/ycc.go b/vendor/github.com/nfnt/resize/ycc.go
index 104159955e12fe3c743eb49054dfa5c67fef5753..143e4d06ac8639033519c55b481d5c4630908d61 100644 (file)
--- a/vendor/github.com/nfnt/resize/ycc.go
+++ b/vendor/github.com/nfnt/resize/ycc.go
@@ -88,140 +88,300 @@ func newYCC(r image.Rectangle, s image.YCbCrSubsampleRatio) *ycc {
        return &ycc{Pix: buf, Stride: 3 * w, Rect: r, SubsampleRatio: s}
 }
 
+// Copy of image.YCbCrSubsampleRatio constants - this allows us to support
+// older versions of Go where these constants are not defined (i.e. Go 1.4)
+const (
+       ycbcrSubsampleRatio444 image.YCbCrSubsampleRatio = iota
+       ycbcrSubsampleRatio422
+       ycbcrSubsampleRatio420
+       ycbcrSubsampleRatio440
+       ycbcrSubsampleRatio411
+       ycbcrSubsampleRatio410
+)
+
 // YCbCr converts ycc to a YCbCr image with the same subsample ratio
 // as the YCbCr image that ycc was generated from.
 func (p *ycc) YCbCr() *image.YCbCr {
        ycbcr := image.NewYCbCr(p.Rect, p.SubsampleRatio)
+       switch ycbcr.SubsampleRatio {
+       case ycbcrSubsampleRatio422:
+               return p.ycbcr422(ycbcr)
+       case ycbcrSubsampleRatio420:
+               return p.ycbcr420(ycbcr)
+       case ycbcrSubsampleRatio440:
+               return p.ycbcr440(ycbcr)
+       case ycbcrSubsampleRatio444:
+               return p.ycbcr444(ycbcr)
+       case ycbcrSubsampleRatio411:
+               return p.ycbcr411(ycbcr)
+       case ycbcrSubsampleRatio410:
+               return p.ycbcr410(ycbcr)
+       }
+       return ycbcr
+}
+
+// imageYCbCrToYCC converts a YCbCr image to a ycc image for resizing.
+func imageYCbCrToYCC(in *image.YCbCr) *ycc {
+       w, h := in.Rect.Dx(), in.Rect.Dy()
+       p := ycc{
+               Pix:            make([]uint8, 3*w*h),
+               Stride:         3 * w,
+               Rect:           image.Rect(0, 0, w, h),
+               SubsampleRatio: in.SubsampleRatio,
+       }
+       switch in.SubsampleRatio {
+       case ycbcrSubsampleRatio422:
+               return convertToYCC422(in, &p)
+       case ycbcrSubsampleRatio420:
+               return convertToYCC420(in, &p)
+       case ycbcrSubsampleRatio440:
+               return convertToYCC440(in, &p)
+       case ycbcrSubsampleRatio444:
+               return convertToYCC444(in, &p)
+       case ycbcrSubsampleRatio411:
+               return convertToYCC411(in, &p)
+       case ycbcrSubsampleRatio410:
+               return convertToYCC410(in, &p)
+       }
+       return &p
+}
+
+func (p *ycc) ycbcr422(ycbcr *image.YCbCr) *image.YCbCr {
        var off int
+       Pix := p.Pix
+       Y := ycbcr.Y
+       Cb := ycbcr.Cb
+       Cr := ycbcr.Cr
+       for y := 0; y < ycbcr.Rect.Max.Y-ycbcr.Rect.Min.Y; y++ {
+               yy := y * ycbcr.YStride
+               cy := y * ycbcr.CStride
+               for x := 0; x < ycbcr.Rect.Max.X-ycbcr.Rect.Min.X; x++ {
+                       ci := cy + x/2
+                       Y[yy+x] = Pix[off+0]
+                       Cb[ci] = Pix[off+1]
+                       Cr[ci] = Pix[off+2]
+                       off += 3
+               }
+       }
+       return ycbcr
+}
 
-       switch ycbcr.SubsampleRatio {
-       case image.YCbCrSubsampleRatio422:
-               for y := ycbcr.Rect.Min.Y; y < ycbcr.Rect.Max.Y; y++ {
-                       yy := (y - ycbcr.Rect.Min.Y) * ycbcr.YStride
-                       cy := (y - ycbcr.Rect.Min.Y) * ycbcr.CStride
-                       for x := ycbcr.Rect.Min.X; x < ycbcr.Rect.Max.X; x++ {
-                               xx := (x - ycbcr.Rect.Min.X)
-                               yi := yy + xx
-                               ci := cy + xx/2
-                               ycbcr.Y[yi] = p.Pix[off+0]
-                               ycbcr.Cb[ci] = p.Pix[off+1]
-                               ycbcr.Cr[ci] = p.Pix[off+2]
-                               off += 3
-                       }
+func (p *ycc) ycbcr420(ycbcr *image.YCbCr) *image.YCbCr {
+       var off int
+       Pix := p.Pix
+       Y := ycbcr.Y
+       Cb := ycbcr.Cb
+       Cr := ycbcr.Cr
+       for y := 0; y < ycbcr.Rect.Max.Y-ycbcr.Rect.Min.Y; y++ {
+               yy := y * ycbcr.YStride
+               cy := (y / 2) * ycbcr.CStride
+               for x := 0; x < ycbcr.Rect.Max.X-ycbcr.Rect.Min.X; x++ {
+                       ci := cy + x/2
+                       Y[yy+x] = Pix[off+0]
+                       Cb[ci] = Pix[off+1]
+                       Cr[ci] = Pix[off+2]
+                       off += 3
                }
-       case image.YCbCrSubsampleRatio420:
-               for y := ycbcr.Rect.Min.Y; y < ycbcr.Rect.Max.Y; y++ {
-                       yy := (y - ycbcr.Rect.Min.Y) * ycbcr.YStride
-                       cy := (y/2 - ycbcr.Rect.Min.Y/2) * ycbcr.CStride
-                       for x := ycbcr.Rect.Min.X; x < ycbcr.Rect.Max.X; x++ {
-                               xx := (x - ycbcr.Rect.Min.X)
-                               yi := yy + xx
-                               ci := cy + xx/2
-                               ycbcr.Y[yi] = p.Pix[off+0]
-                               ycbcr.Cb[ci] = p.Pix[off+1]
-                               ycbcr.Cr[ci] = p.Pix[off+2]
-                               off += 3
-                       }
+       }
+       return ycbcr
+}
+
+func (p *ycc) ycbcr440(ycbcr *image.YCbCr) *image.YCbCr {
+       var off int
+       Pix := p.Pix
+       Y := ycbcr.Y
+       Cb := ycbcr.Cb
+       Cr := ycbcr.Cr
+       for y := 0; y < ycbcr.Rect.Max.Y-ycbcr.Rect.Min.Y; y++ {
+               yy := y * ycbcr.YStride
+               cy := (y / 2) * ycbcr.CStride
+               for x := 0; x < ycbcr.Rect.Max.X-ycbcr.Rect.Min.X; x++ {
+                       ci := cy + x
+                       Y[yy+x] = Pix[off+0]
+                       Cb[ci] = Pix[off+1]
+                       Cr[ci] = Pix[off+2]
+                       off += 3
                }
-       case image.YCbCrSubsampleRatio440:
-               for y := ycbcr.Rect.Min.Y; y < ycbcr.Rect.Max.Y; y++ {
-                       yy := (y - ycbcr.Rect.Min.Y) * ycbcr.YStride
-                       cy := (y/2 - ycbcr.Rect.Min.Y/2) * ycbcr.CStride
-                       for x := ycbcr.Rect.Min.X; x < ycbcr.Rect.Max.X; x++ {
-                               xx := (x - ycbcr.Rect.Min.X)
-                               yi := yy + xx
-                               ci := cy + xx
-                               ycbcr.Y[yi] = p.Pix[off+0]
-                               ycbcr.Cb[ci] = p.Pix[off+1]
-                               ycbcr.Cr[ci] = p.Pix[off+2]
-                               off += 3
-                       }
+       }
+       return ycbcr
+}
+
+func (p *ycc) ycbcr444(ycbcr *image.YCbCr) *image.YCbCr {
+       var off int
+       Pix := p.Pix
+       Y := ycbcr.Y
+       Cb := ycbcr.Cb
+       Cr := ycbcr.Cr
+       for y := 0; y < ycbcr.Rect.Max.Y-ycbcr.Rect.Min.Y; y++ {
+               yy := y * ycbcr.YStride
+               cy := y * ycbcr.CStride
+               for x := 0; x < ycbcr.Rect.Max.X-ycbcr.Rect.Min.X; x++ {
+                       ci := cy + x
+                       Y[yy+x] = Pix[off+0]
+                       Cb[ci] = Pix[off+1]
+                       Cr[ci] = Pix[off+2]
+                       off += 3
+               }
+       }
+       return ycbcr
+}
+
+func (p *ycc) ycbcr411(ycbcr *image.YCbCr) *image.YCbCr {
+       var off int
+       Pix := p.Pix
+       Y := ycbcr.Y
+       Cb := ycbcr.Cb
+       Cr := ycbcr.Cr
+       for y := 0; y < ycbcr.Rect.Max.Y-ycbcr.Rect.Min.Y; y++ {
+               yy := y * ycbcr.YStride
+               cy := y * ycbcr.CStride
+               for x := 0; x < ycbcr.Rect.Max.X-ycbcr.Rect.Min.X; x++ {
+                       ci := cy + x/4
+                       Y[yy+x] = Pix[off+0]
+                       Cb[ci] = Pix[off+1]
+                       Cr[ci] = Pix[off+2]
+                       off += 3
                }
-       default:
-               // Default to 4:4:4 subsampling.
-               for y := ycbcr.Rect.Min.Y; y < ycbcr.Rect.Max.Y; y++ {
-                       yy := (y - ycbcr.Rect.Min.Y) * ycbcr.YStride
-                       cy := (y - ycbcr.Rect.Min.Y) * ycbcr.CStride
-                       for x := ycbcr.Rect.Min.X; x < ycbcr.Rect.Max.X; x++ {
-                               xx := (x - ycbcr.Rect.Min.X)
-                               yi := yy + xx
-                               ci := cy + xx
-                               ycbcr.Y[yi] = p.Pix[off+0]
-                               ycbcr.Cb[ci] = p.Pix[off+1]
-                               ycbcr.Cr[ci] = p.Pix[off+2]
-                               off += 3
-                       }
+       }
+       return ycbcr
+}
+
+func (p *ycc) ycbcr410(ycbcr *image.YCbCr) *image.YCbCr {
+       var off int
+       Pix := p.Pix
+       Y := ycbcr.Y
+       Cb := ycbcr.Cb
+       Cr := ycbcr.Cr
+       for y := 0; y < ycbcr.Rect.Max.Y-ycbcr.Rect.Min.Y; y++ {
+               yy := y * ycbcr.YStride
+               cy := (y / 2) * ycbcr.CStride
+               for x := 0; x < ycbcr.Rect.Max.X-ycbcr.Rect.Min.X; x++ {
+                       ci := cy + x/4
+                       Y[yy+x] = Pix[off+0]
+                       Cb[ci] = Pix[off+1]
+                       Cr[ci] = Pix[off+2]
+                       off += 3
                }
        }
        return ycbcr
 }
 
-// imageYCbCrToYCC converts a YCbCr image to a ycc image for resizing.
-func imageYCbCrToYCC(in *image.YCbCr) *ycc {
-       w, h := in.Rect.Dx(), in.Rect.Dy()
-       r := image.Rect(0, 0, w, h)
-       buf := make([]uint8, 3*w*h)
-       p := ycc{Pix: buf, Stride: 3 * w, Rect: r, SubsampleRatio: in.SubsampleRatio}
+func convertToYCC422(in *image.YCbCr, p *ycc) *ycc {
        var off int
+       Pix := p.Pix
+       Y := in.Y
+       Cb := in.Cb
+       Cr := in.Cr
+       for y := 0; y < in.Rect.Max.Y-in.Rect.Min.Y; y++ {
+               yy := y * in.YStride
+               cy := y * in.CStride
+               for x := 0; x < in.Rect.Max.X-in.Rect.Min.X; x++ {
+                       ci := cy + x/2
+                       Pix[off+0] = Y[yy+x]
+                       Pix[off+1] = Cb[ci]
+                       Pix[off+2] = Cr[ci]
+                       off += 3
+               }
+       }
+       return p
+}
 
-       switch in.SubsampleRatio {
-       case image.YCbCrSubsampleRatio422:
-               for y := in.Rect.Min.Y; y < in.Rect.Max.Y; y++ {
-                       yy := (y - in.Rect.Min.Y) * in.YStride
-                       cy := (y - in.Rect.Min.Y) * in.CStride
-                       for x := in.Rect.Min.X; x < in.Rect.Max.X; x++ {
-                               xx := (x - in.Rect.Min.X)
-                               yi := yy + xx
-                               ci := cy + xx/2
-                               p.Pix[off+0] = in.Y[yi]
-                               p.Pix[off+1] = in.Cb[ci]
-                               p.Pix[off+2] = in.Cr[ci]
-                               off += 3
-                       }
+func convertToYCC420(in *image.YCbCr, p *ycc) *ycc {
+       var off int
+       Pix := p.Pix
+       Y := in.Y
+       Cb := in.Cb
+       Cr := in.Cr
+       for y := 0; y < in.Rect.Max.Y-in.Rect.Min.Y; y++ {
+               yy := y * in.YStride
+               cy := (y / 2) * in.CStride
+               for x := 0; x < in.Rect.Max.X-in.Rect.Min.X; x++ {
+                       ci := cy + x/2
+                       Pix[off+0] = Y[yy+x]
+                       Pix[off+1] = Cb[ci]
+                       Pix[off+2] = Cr[ci]
+                       off += 3
                }
-       case image.YCbCrSubsampleRatio420:
-               for y := in.Rect.Min.Y; y < in.Rect.Max.Y; y++ {
-                       yy := (y - in.Rect.Min.Y) * in.YStride
-                       cy := (y/2 - in.Rect.Min.Y/2) * in.CStride
-                       for x := in.Rect.Min.X; x < in.Rect.Max.X; x++ {
-                               xx := (x - in.Rect.Min.X)
-                               yi := yy + xx
-                               ci := cy + xx/2
-                               p.Pix[off+0] = in.Y[yi]
-                               p.Pix[off+1] = in.Cb[ci]
-                               p.Pix[off+2] = in.Cr[ci]
-                               off += 3
-                       }
+       }
+       return p
+}
+
+func convertToYCC440(in *image.YCbCr, p *ycc) *ycc {
+       var off int
+       Pix := p.Pix
+       Y := in.Y
+       Cb := in.Cb
+       Cr := in.Cr
+       for y := 0; y < in.Rect.Max.Y-in.Rect.Min.Y; y++ {
+               yy := y * in.YStride
+               cy := (y / 2) * in.CStride
+               for x := 0; x < in.Rect.Max.X-in.Rect.Min.X; x++ {
+                       ci := cy + x
+                       Pix[off+0] = Y[yy+x]
+                       Pix[off+1] = Cb[ci]
+                       Pix[off+2] = Cr[ci]
+                       off += 3
                }
-       case image.YCbCrSubsampleRatio440:
-               for y := in.Rect.Min.Y; y < in.Rect.Max.Y; y++ {
-                       yy := (y - in.Rect.Min.Y) * in.YStride
-                       cy := (y/2 - in.Rect.Min.Y/2) * in.CStride
-                       for x := in.Rect.Min.X; x < in.Rect.Max.X; x++ {
-                               xx := (x - in.Rect.Min.X)
-                               yi := yy + xx
-                               ci := cy + xx
-                               p.Pix[off+0] = in.Y[yi]
-                               p.Pix[off+1] = in.Cb[ci]
-                               p.Pix[off+2] = in.Cr[ci]
-                               off += 3
-                       }
+       }
+       return p
+}
+
+func convertToYCC444(in *image.YCbCr, p *ycc) *ycc {
+       var off int
+       Pix := p.Pix
+       Y := in.Y
+       Cb := in.Cb
+       Cr := in.Cr
+       for y := 0; y < in.Rect.Max.Y-in.Rect.Min.Y; y++ {
+               yy := y * in.YStride
+               cy := y * in.CStride
+               for x := 0; x < in.Rect.Max.X-in.Rect.Min.X; x++ {
+                       ci := cy + x
+                       Pix[off+0] = Y[yy+x]
+                       Pix[off+1] = Cb[ci]
+                       Pix[off+2] = Cr[ci]
+                       off += 3
                }
-       default:
-               // Default to 4:4:4 subsampling.
-               for y := in.Rect.Min.Y; y < in.Rect.Max.Y; y++ {
-                       yy := (y - in.Rect.Min.Y) * in.YStride
-                       cy := (y - in.Rect.Min.Y) * in.CStride
-                       for x := in.Rect.Min.X; x < in.Rect.Max.X; x++ {
-                               xx := (x - in.Rect.Min.X)
-                               yi := yy + xx
-                               ci := cy + xx
-                               p.Pix[off+0] = in.Y[yi]
-                               p.Pix[off+1] = in.Cb[ci]
-                               p.Pix[off+2] = in.Cr[ci]
-                               off += 3
-                       }
+       }
+       return p
+}
+
+func convertToYCC411(in *image.YCbCr, p *ycc) *ycc {
+       var off int
+       Pix := p.Pix
+       Y := in.Y
+       Cb := in.Cb
+       Cr := in.Cr
+       for y := 0; y < in.Rect.Max.Y-in.Rect.Min.Y; y++ {
+               yy := y * in.YStride
+               cy := y * in.CStride
+               for x := 0; x < in.Rect.Max.X-in.Rect.Min.X; x++ {
+                       ci := cy + x/4
+                       Pix[off+0] = Y[yy+x]
+                       Pix[off+1] = Cb[ci]
+                       Pix[off+2] = Cr[ci]
+                       off += 3
                }
        }
-       return &p
+       return p
+}
+
+func convertToYCC410(in *image.YCbCr, p *ycc) *ycc {
+       var off int
+       Pix := p.Pix
+       Y := in.Y
+       Cb := in.Cb
+       Cr := in.Cr
+       for y := 0; y < in.Rect.Max.Y-in.Rect.Min.Y; y++ {
+               yy := y * in.YStride
+               cy := (y / 2) * in.CStride
+               for x := 0; x < in.Rect.Max.X-in.Rect.Min.X; x++ {
+                       ci := cy + x/4
+                       Pix[off+0] = Y[yy+x]
+                       Pix[off+1] = Cb[ci]
+                       Pix[off+2] = Cr[ci]
+                       off += 3
+               }
+       }
+       return p
 }

diff --git a/vendor/modules.txt b/vendor/modules.txt
index 2a69c1077d47f15da867f2584cfbb9c5c095c40d..251019b8bc2e5fc20b15ce30f70fd385b4cbbebb 100644 (file)
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -518,7 +518,7 @@ github.com/mschoch/smat
 # github.com/msteinert/pam v0.0.0-20151204160544-02ccfbfaf0cc
 ## explicit
 github.com/msteinert/pam
-# github.com/nfnt/resize v0.0.0-20160724205520-891127d8d1b5
+# github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
 ## explicit
 github.com/nfnt/resize
 # github.com/niklasfasching/go-org v0.1.9