doc: update README for v1.0.2 release

.gitignore

@@ -0,0 +1,2 @@
+cmd/mkthumb/mkthumb
+cmd/mkthumb/mkthumb.exe

.hgignore

@@ -1,2 +0,0 @@
-
-_dist/

.hgtags

@@ -1,6 +0,0 @@
-efd7b407177086c57e8c086605c2c8d1cee23840 release-1.0
-292439a79182796c2f6277ef13ca179379b0fb88 v0.2.0
-efd7b407177086c57e8c086605c2c8d1cee23840 v0.1.0
-efd7b407177086c57e8c086605c2c8d1cee23840 release-1.0
-0000000000000000000000000000000000000000 release-1.0
-2052254b2599ab6aa6a8de17a61f94646e2a62ef v0.2.1

CachingThumbnailer.go

@@ -1,6 +1,9 @@
 package thumbnail
 
 import (
+	"mime"
+	"path/filepath"
+
 	lru "github.com/hashicorp/golang-lru"
 )
 
@@ -9,6 +12,8 @@ type CachingThumbnailer struct {
 	cache *lru.Cache // threadsafe, might be nil
 }
 
+var _ Thumbnailer = &CachingThumbnailer{} // interface assertion
+
 func NewCachingThumbnailer(cacheSize int, opts *Config) (Thumbnailer, error) {
 
 	upstream := NewThumbnailerEx(opts)
@@ -29,7 +34,11 @@ func NewCachingThumbnailer(cacheSize int, opts *Config) (Thumbnailer, error) {
 }
 
 func (this *CachingThumbnailer) RenderFile(absPath string) ([]byte, error) {
+	mimeType := mime.TypeByExtension(filepath.Ext(absPath))
+	return this.RenderFileAs(absPath, mimeType)
+}
 
+func (this *CachingThumbnailer) RenderFileAs(absPath, mimeType string) ([]byte, error) {
 	thumb, ok := this.cache.Get(absPath)
 	if ok {
 		return thumb.([]byte), nil

DirectThumbnailer.go

@@ -11,6 +11,8 @@ type DirectThumbnailer struct {
 	cfg Config
 }
 
+var _ Thumbnailer = &DirectThumbnailer{} // interface assertion
+
 func NewThumbnailer(w, h int) Thumbnailer {
 	opts := DefaultConfig
 	opts.Width = w
@@ -29,6 +31,10 @@ func NewThumbnailerEx(opts *Config) Thumbnailer {
 
 func (this *DirectThumbnailer) RenderFile(absPath string) ([]byte, error) {
 	mimeType := mime.TypeByExtension(filepath.Ext(absPath))
+	return this.RenderFileAs(absPath, mimeType)
+}
+
+func (this *DirectThumbnailer) RenderFileAs(absPath, mimeType string) ([]byte, error) {
 
 	// Decode source
 

Gopkg.lock

@@ -1,27 +0,0 @@
-# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
-
-
-[[projects]]
-  branch = "master"
-  name = "code.ivysaur.me/imagequant"
-  packages = ["."]
-  revision = "6a468707fb1bb44c4bb71113273cc73daf401976"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/hashicorp/golang-lru"
-  packages = [".","simplelru"]
-  revision = "0fb14efe8c47ae851c0034ed7a448854d3d34cf3"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/image"
-  packages = ["bmp","draw","math/f64","riff","vp8","vp8l","webp"]
-  revision = "af66defab954cb421ca110193eed9477c8541e2a"
-
-[solve-meta]
-  analyzer-name = "dep"
-  analyzer-version = 1
-  inputs-digest = "bbec1c5a83e20c224400fbd1c97a4c81d91429b7a6b22f05a579788b101a7e72"
-  solver-name = "gps-cdcl"
-  solver-version = 1

Gopkg.toml

@@ -1,34 +0,0 @@
-
-# Gopkg.toml example
-#
-# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
-# for detailed Gopkg.toml documentation.
-#
-# required = ["github.com/user/thing/cmd/thing"]
-# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
-#
-# [[constraint]]
-#   name = "github.com/user/project"
-#   version = "1.0.0"
-#
-# [[constraint]]
-#   name = "github.com/user/project2"
-#   branch = "dev"
-#   source = "github.com/myfork/project2"
-#
-# [[override]]
-#  name = "github.com/x/y"
-#  version = "2.4.0"
-
-
-[[constraint]]
-  branch = "master"
-  name = "code.ivysaur.me/imagequant"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/hashicorp/golang-lru"
-
-[[constraint]]
-  branch = "master"
-  name = "golang.org/x/image"

README.md

@@ -1,20 +1,28 @@
-A thumbnailing library for Go.
+# thumbnail
 
-Written in Go
+A thumbnailing library for Go.
 
 - Supports jpeg / png / gif / bmp / webp files (internally)
 - Supports video files (requires `ffmpeg` in `$PATH`)
 - Optional LRU cache of recent thumbnails for performance
 - Sampling algorithms: Nearest-neighbour, Bilinear (fast), Bilinear (accurate), Bicubic (Catmull-Rom)
 - Scaling algorithms: Fit inside, Fit outside, Stretch
-- Output formats: JPG, PNG, Quantised/lossy PNG (via `go-imagequant`), BMP
+- Output formats: JPG, PNG, Quantised/lossy PNG (via `go-imagequant` if CGO is available), BMP
 
 A standalone binary `mkthumb` is provided as a sample utility.
 
 This package can be installed via go get: `go get code.ivysaur.me/thumbnail`
-[go-get]code.ivysaur.me/thumbnail git https://git.ivysaur.me/code.ivysaur.me/thumbnail.git[/go-get]
 
-=CHANGELOG=
+## Changelog
+
+2020-07-25 1.0.2
+- Automatically build pngquant support if CGO is available
+- Remove vendor directory, rely more heavily on Go Modules
+- Update module dependencies
+
+2018-12-31 1.0.1
+- Convert to Go Modules
+- Update vendored dependencies
 
 2018-06-09 1.0.0
 - Feature: Major speed improvement
@@ -24,14 +32,17 @@ This package can be installed via go get: `go get code.ivysaur.me/thumbnail`
 - Feature: Support Webp and BMP input files
 - Fix wrong dimension output for video input files
 - Fix jagged output of bilinear resizer
+- [⬇️ thumbnail-1.0.0-src.tar.xz](https://git.ivysaur.me/attachments/aa9c5b40-3faa-45c3-a45e-10004d03481c) *(4.78 KiB)*
 
 2018-06-04 0.2.1
 - Add `disableimagecrush` build tag option to exclude cgo library dependency
+- [⬇️ thumbnail-0.2.1-src.zip](https://git.ivysaur.me/attachments/08c12811-fc7b-44b0-93fd-161091632e9e) *(24.09 KiB)*
 
 2017-11-18 0.2.0
 - Initial standalone release
 - Feature: Decode input with specified mime type
 - Feature: Allow passing zero as thumbnail cache size
+- [⬇️ thumbnail-0.2.0-src.zip](https://git.ivysaur.me/attachments/c2405a1a-50c3-4059-9b49-a77bc2ee311f) *(23.37 KiB)*
 
 2017-01-03 0.1.0
 - Version of `thumbnail` vendored with `webdir` 1.0 (previously tagged as `release-1.0`)

Thumbnailer.go

@@ -12,6 +12,7 @@ var (
 
 type Thumbnailer interface {
 	RenderFile(absPath string) ([]byte, error)
+	RenderFileAs(absPath, mimeType string) ([]byte, error)
 }
 
 func FiletypeSupported(ext string) bool {

cmd/mkthumb/Makefile

@@ -1,9 +0,0 @@
-.PHONY: all
-
-all: mkthumb
-
-clean:
-	rm ./mkthumb
-
-mkthumb: mkthumb.go
-	go build -ldflags '-s -w'

go.mod

@@ -0,0 +1,9 @@
+module code.ivysaur.me/thumbnail
+
+require (
+	code.ivysaur.me/imagequant/v2 v2.12.6
+	github.com/hashicorp/golang-lru v0.5.4
+	golang.org/x/image v0.0.0-20200618115811-c13761719519
+)
+
+go 1.13

go.sum

@@ -0,0 +1,13 @@
+code.ivysaur.me/imagequant/v2 v2.12.6 h1:xYrGj6GOdAcutmzqBxG7bDZ70r4jYHADOCZ+ktyMU3Y=
+code.ivysaur.me/imagequant/v2 v2.12.6/go.mod h1:seCAm0sP2IBsb1YNBj4D+EZovIuGe16+6Xo0aiGyhDU=
+github.com/hashicorp/golang-lru v0.0.0-20180201235237-0fb14efe8c47 h1:UnszMmmmm5vLwWzDjTFVIkfhvWF1NdrmChl8L2NUDCw=
+github.com/hashicorp/golang-lru v0.0.0-20180201235237-0fb14efe8c47/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.0 h1:CL2msUPvZTLb5O648aiLNJw3hnBxN2+1Jq8rCOH9wdo=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc=
+github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
+golang.org/x/image v0.0.0-20180601115456-af66defab954 h1:n7UB+yxe5jyWxOA3BTAfwi23lhfKEIddaB/so7YOYe0=
+golang.org/x/image v0.0.0-20180601115456-af66defab954/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs=
+golang.org/x/image v0.0.0-20200618115811-c13761719519 h1:1e2ufUJNM3lCHEY5jIgac/7UTjd6cgJNdatjPdFWf34=
+golang.org/x/image v0.0.0-20200618115811-c13761719519/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

imagecrush_cgo.go

@@ -1,4 +1,4 @@
-//+build withimagecrush
+//+build cgo
 
 package thumbnail
 
@@ -9,7 +9,7 @@ import (
 	"image/color"
 	"image/png"
 
-	"code.ivysaur.me/imagequant"
+	"code.ivysaur.me/imagequant/v2"
 )
 
 func goImageToRgba32(im image.Image) []byte {

imagecrush_nocgo.go

@@ -1,4 +1,4 @@
-// +build !withimagecrush
+//+build !cgo
 
 package thumbnail
 

vendor/code.ivysaur.me/imagequant/.hgignore

@@ -1,4 +0,0 @@
-mode:regex
-
-^_dist/
-\.exe$

vendor/code.ivysaur.me/imagequant/.hgtags

@@ -1,2 +0,0 @@
-795de1317b3afb38cbc638a95f4324a694f0c5e8 release-2.8go1.0
-2a725298492495e5ac694550b41112f00782850b release-2.9go1.1

vendor/code.ivysaur.me/imagequant/Attributes.go

@@ -1,114 +0,0 @@
-/*
-Copyright (c) 2016, The go-imagequant author(s)
-
-Permission to use, copy, modify, and/or distribute this software for any purpose
-with or without fee is hereby granted, provided that the above copyright notice
-and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD TO
-THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
-IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
-CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
-OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
-ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-SOFTWARE.
-*/
-
-package imagequant
-
-import (
-	"errors"
-)
-
-/*
-#include "libimagequant.h"
-*/
-import "C"
-
-type Attributes struct {
-	p *C.struct_liq_attr
-}
-
-// Callers MUST call Release() on the returned object to free memory.
-func NewAttributes() (*Attributes, error) {
-	pAttr := C.liq_attr_create()
-	if pAttr == nil { // nullptr
-		return nil, errors.New("Unsupported platform")
-	}
-
-	return &Attributes{p: pAttr}, nil
-}
-
-const (
-	COLORS_MIN = 2
-	COLORS_MAX = 256
-)
-
-func (this *Attributes) SetMaxColors(colors int) error {
-	return translateError(C.liq_set_max_colors(this.p, C.int(colors)))
-}
-
-func (this *Attributes) GetMaxColors() int {
-	return int(C.liq_get_max_colors(this.p))
-}
-
-const (
-	QUALITY_MIN = 0
-	QUALITY_MAX = 100
-)
-
-func (this *Attributes) SetQuality(minimum, maximum int) error {
-	return translateError(C.liq_set_quality(this.p, C.int(minimum), C.int(maximum)))
-}
-
-func (this *Attributes) GetMinQuality() int {
-	return int(C.liq_get_min_quality(this.p))
-}
-
-func (this *Attributes) GetMaxQuality() int {
-	return int(C.liq_get_max_quality(this.p))
-}
-
-const (
-	SPEED_SLOWEST = 1
-	SPEED_DEFAULT = 3
-	SPEED_FASTEST = 10
-)
-
-func (this *Attributes) SetSpeed(speed int) error {
-	return translateError(C.liq_set_speed(this.p, C.int(speed)))
-}
-
-func (this *Attributes) GetSpeed() int {
-	return int(C.liq_get_speed(this.p))
-}
-
-func (this *Attributes) SetMinOpacity(min int) error {
-	return translateError(C.liq_set_min_opacity(this.p, C.int(min)))
-}
-
-func (this *Attributes) GetMinOpacity() int {
-	return int(C.liq_get_min_opacity(this.p))
-}
-
-func (this *Attributes) SetMinPosterization(bits int) error {
-	return translateError(C.liq_set_min_posterization(this.p, C.int(bits)))
-}
-
-func (this *Attributes) GetMinPosterization() int {
-	return int(C.liq_get_min_posterization(this.p))
-}
-
-func (this *Attributes) SetLastIndexTransparent(is_last int) {
-	C.liq_set_last_index_transparent(this.p, C.int(is_last))
-}
-
-func (this *Attributes) CreateHistogram() *Histogram {
-	ptr := C.liq_histogram_create(this.p)
-	return &Histogram{p: ptr}
-}
-
-// Free memory. Callers must not use this object after Release has been called.
-func (this *Attributes) Release() {
-	C.liq_attr_destroy(this.p)
-}

vendor/code.ivysaur.me/imagequant/COPYRIGHT

@@ -1,641 +0,0 @@
-
-libimagequant is derived from code by Jef Poskanzer and Greg Roelofs
-licensed under pngquant's original license (at the end of this file),
-and contains extensive changes and additions by Kornel Lesiński
-licensed under GPL v3.
-
-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-libimagequant © 2009-2016 by Kornel Lesiński.
-
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-© 1989, 1991 by Jef Poskanzer.
-© 1997, 2000, 2002 by Greg Roelofs.
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee is hereby granted, provided
-that the above copyright notice appear in all copies and that both that
-copyright notice and this permission notice appear in supporting
-documentation.  This software is provided "as is" without express or
-implied warranty.

vendor/code.ivysaur.me/imagequant/Histogram.go

@@ -1,45 +0,0 @@
-/*
-Copyright (c) 2016, The go-imagequant author(s)
-
-Permission to use, copy, modify, and/or distribute this software for any purpose
-with or without fee is hereby granted, provided that the above copyright notice
-and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD TO
-THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
-IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
-CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
-OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
-ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-SOFTWARE.
-*/
-
-package imagequant
-
-/*
-#include "libimagequant.h"
-*/
-import "C"
-
-type Histogram struct {
-	p *C.struct_liq_histogram
-}
-
-func (this *Histogram) AddImage(attr *Attributes, img *Image) error {
-	return translateError(C.liq_histogram_add_image(this.p, attr.p, img.p))
-}
-
-func (this *Histogram) Quantize(attr *Attributes) (*Result, error) {
-	res := Result{}
-	liqerr := C.liq_histogram_quantize(this.p, attr.p, &res.p)
-	if liqerr != C.LIQ_OK {
-		return nil, translateError(liqerr)
-	}
-
-	return &res, nil
-}
-
-// Free memory. Callers must not use this object after Release has been called.
-func (this *Histogram) Release() {
-	C.liq_histogram_destroy(this.p)
-}

vendor/code.ivysaur.me/imagequant/Image.go

@@ -1,66 +0,0 @@
-/*
-Copyright (c) 2016, The go-imagequant author(s)
-
-Permission to use, copy, modify, and/or distribute this software for any purpose
-with or without fee is hereby granted, provided that the above copyright notice
-and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD TO
-THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
-IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
-CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
-OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
-ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-SOFTWARE.
-*/
-
-package imagequant
-
-import (
-	"errors"
-	"unsafe"
-)
-
-/*
-#include "libimagequant.h"
-*/
-import "C"
-
-type Image struct {
-	p        *C.struct_liq_image
-	w, h     int
-	released bool
-}
-
-// Callers MUST call Release() on the returned object to free memory.
-func NewImage(attr *Attributes, rgba32data string, width, height int, gamma float64) (*Image, error) {
-	pImg := C.liq_image_create_rgba(attr.p, unsafe.Pointer(C.CString(rgba32data)), C.int(width), C.int(height), C.double(gamma))
-	if pImg == nil {
-		return nil, errors.New("Failed to create image (invalid argument)")
-	}
-
-	return &Image{
-		p:        pImg,
-		w:        width,
-		h:        height,
-		released: false,
-	}, nil
-}
-
-// Free memory. Callers must not use this object after Release has been called.
-func (this *Image) Release() {
-	C.liq_image_destroy(this.p)
-	this.released = true
-}
-
-func (this *Image) Quantize(attr *Attributes) (*Result, error) {
-	res := Result{
-		im: this,
-	}
-	liqerr := C.liq_image_quantize(this.p, attr.p, &res.p)
-	if liqerr != C.LIQ_OK {
-		return nil, translateError(liqerr)
-	}
-
-	return &res, nil
-}

vendor/code.ivysaur.me/imagequant/Result.go

@@ -1,110 +0,0 @@
-/*
-Copyright (c) 2016, The go-imagequant author(s)
-
-Permission to use, copy, modify, and/or distribute this software for any purpose
-with or without fee is hereby granted, provided that the above copyright notice
-and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD TO
-THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
-IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
-CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
-OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
-ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-SOFTWARE.
-*/
-
-package imagequant
-
-import (
-	"image/color"
-	"unsafe"
-)
-
-/*
-#include "libimagequant.h"
-*/
-import "C"
-
-// Callers must not use this object once Release has been called on the parent
-// Image struct.
-type Result struct {
-	p  *C.struct_liq_result
-	im *Image
-}
-
-func (this *Result) SetDitheringLevel(dither_level float32) error {
-	return translateError(C.liq_set_dithering_level(this.p, C.float(dither_level)))
-}
-
-func (this *Result) GetQuantizationError() float64 {
-	return float64(C.liq_get_quantization_error(this.p))
-}
-
-func (this *Result) GetRemappingError() float64 {
-	return float64(C.liq_get_remapping_error(this.p))
-}
-
-func (this *Result) GetQuantizationQuality() float64 {
-	return float64(C.liq_get_quantization_quality(this.p))
-}
-
-func (this *Result) GetRemappingQuality() float64 {
-	return float64(C.liq_get_remapping_quality(this.p))
-}
-
-func (this *Result) SetOutputGamma(gamma float64) error {
-	return translateError(C.liq_set_output_gamma(this.p, C.double(gamma)))
-}
-
-func (this *Result) GetImageWidth() int {
-	// C.liq_image_get_width
-	return this.im.w
-}
-
-func (this *Result) GetImageHeight() int {
-	// C.liq_image_get_height
-	return this.im.h
-}
-
-func (this *Result) GetOutputGamma() float64 {
-	return float64(C.liq_get_output_gamma(this.p))
-}
-
-func (this *Result) WriteRemappedImage() ([]byte, error) {
-	if this.im.released {
-		return nil, ErrUseAfterFree
-	}
-
-	buff_size := this.im.w * this.im.h
-	buff := make([]byte, buff_size)
-
-	iqe := C.liq_write_remapped_image(this.p, this.im.p, unsafe.Pointer(&buff[0]), C.size_t(buff_size))
-	if iqe != C.LIQ_OK {
-		return nil, translateError(iqe)
-	}
-
-	return buff, nil
-}
-
-func (this *Result) GetPalette() color.Palette {
-	ptr := C.liq_get_palette(this.p) // copy struct content
-	max := int(ptr.count)
-
-	ret := make([]color.Color, max)
-	for i := 0; i < max; i += 1 {
-		ret[i] = color.RGBA{
-			R: uint8(ptr.entries[i].r),
-			G: uint8(ptr.entries[i].g),
-			B: uint8(ptr.entries[i].b),
-			A: uint8(ptr.entries[i].a),
-		}
-	}
-
-	return ret
-}
-
-// Free memory. Callers must not use this object after Release has been called.
-func (this *Result) Release() {
-	C.liq_result_destroy(this.p)
-}

vendor/code.ivysaur.me/imagequant/blur.c

@@ -1,132 +0,0 @@
-/*
-© 2011-2015 by Kornel Lesiński.
-
-This file is part of libimagequant.
-
-libimagequant is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-libimagequant is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with libimagequant. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "libimagequant.h"
-#include "pam.h"
-#include "blur.h"
-
-/*
- Blurs image horizontally (width 2*size+1) and writes it transposed to dst (called twice gives 2d blur)
- */
-static void transposing_1d_blur(unsigned char *restrict src, unsigned char *restrict dst, unsigned int width, unsigned int height, const unsigned int size)
-{
-    assert(size > 0);
-
-    for(unsigned int j=0; j < height; j++) {
-        unsigned char *restrict row = src + j*width;
-
-        // accumulate sum for pixels outside line
-        unsigned int sum;
-        sum = row[0]*size;
-        for(unsigned int i=0; i < size; i++) {
-            sum += row[i];
-        }
-
-        // blur with left side outside line
-        for(unsigned int i=0; i < size; i++) {
-            sum -= row[0];
-            sum += row[i+size];
-
-            dst[i*height + j] = sum / (size*2);
-        }
-
-        for(unsigned int i=size; i < width-size; i++) {
-            sum -= row[i-size];
-            sum += row[i+size];
-
-            dst[i*height + j] = sum / (size*2);
-        }
-
-        // blur with right side outside line
-        for(unsigned int i=width-size; i < width; i++) {
-            sum -= row[i-size];
-            sum += row[width-1];
-
-            dst[i*height + j] = sum / (size*2);
-        }
-    }
-}
-
-/**
- * Picks maximum of neighboring pixels (blur + lighten)
- */
-LIQ_PRIVATE void liq_max3(unsigned char *src, unsigned char *dst, unsigned int width, unsigned int height)
-{
-    for(unsigned int j=0; j < height; j++) {
-        const unsigned char *row = src + j*width,
-        *prevrow = src + (j > 1 ? j-1 : 0)*width,
-        *nextrow = src + MIN(height-1,j+1)*width;
-
-        unsigned char prev,curr=row[0],next=row[0];
-
-        for(unsigned int i=0; i < width-1; i++) {
-            prev=curr;
-            curr=next;
-            next=row[i+1];
-
-            unsigned char t1 = MAX(prev,next);
-            unsigned char t2 = MAX(nextrow[i],prevrow[i]);
-            *dst++ = MAX(curr,MAX(t1,t2));
-        }
-        unsigned char t1 = MAX(curr,next);
-        unsigned char t2 = MAX(nextrow[width-1],prevrow[width-1]);
-        *dst++ = MAX(t1,t2);
-    }
-}
-
-/**
- * Picks minimum of neighboring pixels (blur + darken)
- */
-LIQ_PRIVATE void liq_min3(unsigned char *src, unsigned char *dst, unsigned int width, unsigned int height)
-{
-    for(unsigned int j=0; j < height; j++) {
-        const unsigned char *row = src + j*width,
-        *prevrow = src + (j > 1 ? j-1 : 0)*width,
-        *nextrow = src + MIN(height-1,j+1)*width;
-
-        unsigned char prev,curr=row[0],next=row[0];
-
-        for(unsigned int i=0; i < width-1; i++) {
-            prev=curr;
-            curr=next;
-            next=row[i+1];
-
-            unsigned char t1 = MIN(prev,next);
-            unsigned char t2 = MIN(nextrow[i],prevrow[i]);
-            *dst++ = MIN(curr,MIN(t1,t2));
-        }
-        unsigned char t1 = MIN(curr,next);
-        unsigned char t2 = MIN(nextrow[width-1],prevrow[width-1]);
-        *dst++ = MIN(t1,t2);
-    }
-}
-
-/*
- Filters src image and saves it to dst, overwriting tmp in the process.
- Image must be width*height pixels high. Size controls radius of box blur.
- */
-LIQ_PRIVATE void liq_blur(unsigned char *src, unsigned char *tmp, unsigned char *dst, unsigned int width, unsigned int height, unsigned int size)
-{
-    assert(size > 0);
-    if (width < 2*size+1 || height < 2*size+1) {
-        return;
-    }
-    transposing_1d_blur(src, tmp, width, height, size);
-    transposing_1d_blur(tmp, dst, height, width, size);
-}

vendor/code.ivysaur.me/imagequant/blur.h

@@ -1,4 +0,0 @@
-
-LIQ_PRIVATE void liq_blur(unsigned char *src, unsigned char *tmp, unsigned char *dst, unsigned int width, unsigned int height, unsigned int size);
-LIQ_PRIVATE void liq_max3(unsigned char *src, unsigned char *dst, unsigned int width, unsigned int height);
-LIQ_PRIVATE void liq_min3(unsigned char *src, unsigned char *dst, unsigned int width, unsigned int height);

vendor/code.ivysaur.me/imagequant/cflags_linux.go

@@ -1,9 +0,0 @@
-//+build !windows
-
-package imagequant
-
-/*
-#cgo CFLAGS: -O3 -fno-math-errno -fopenmp -funroll-loops -fomit-frame-pointer -Wall -Wno-attributes -std=c99 -DNDEBUG -DUSE_SSE=1 -msse -fexcess-precision=fast
-#cgo LDFLAGS: -lm -fopenmp -ldl
-*/
-import "C"

vendor/code.ivysaur.me/imagequant/cflags_windows.go

@@ -1,9 +0,0 @@
-//+build windows
-
-package imagequant
-
-/*
-#cgo CFLAGS: -O3 -fno-math-errno -fopenmp -funroll-loops -fomit-frame-pointer -Wall -Wno-attributes -std=c99 -DNDEBUG -DUSE_SSE=1 -msse -fexcess-precision=fast
-#cgo LDFLAGS: -fopenmp -static
-*/
-import "C"

vendor/code.ivysaur.me/imagequant/cmd/gopngquant/Makefile.cygwin

@@ -1,10 +0,0 @@
-
-.PHONY: all clean
-
-all: gopngquant.exe
-
-clean:
-	rm ./gopngquant.exe || true
-	
-gopngquant.exe: main.go
-	( source ~/.cygwin-toolchain-switcher/use-toolchain-x86_64-w64-mingw32.sh && go build -a -ldflags '-s -w' )

vendor/code.ivysaur.me/imagequant/cmd/gopngquant/main.go

@@ -1,156 +0,0 @@
-/*
-Copyright (c) 2016, The go-imagequant author(s)
-
-Permission to use, copy, modify, and/or distribute this software for any purpose
-with or without fee is hereby granted, provided that the above copyright notice
-and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD TO
-THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
-IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
-CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
-OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
-ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-SOFTWARE.
-*/
-
-package main
-
-import (
-	"flag"
-	"fmt"
-	"image"
-	"image/color"
-	"image/png"
-	"os"
-
-	"code.ivysaur.me/imagequant"
-)
-
-func GoImageToRgba32(im image.Image) []byte {
-	w := im.Bounds().Max.X
-	h := im.Bounds().Max.Y
-	ret := make([]byte, w*h*4)
-
-	p := 0
-
-	for y := 0; y < h; y += 1 {
-		for x := 0; x < w; x += 1 {
-			r16, g16, b16, a16 := im.At(x, y).RGBA() // Each value ranges within [0, 0xffff]
-
-			ret[p+0] = uint8(r16 >> 8)
-			ret[p+1] = uint8(g16 >> 8)
-			ret[p+2] = uint8(b16 >> 8)
-			ret[p+3] = uint8(a16 >> 8)
-			p += 4
-		}
-	}
-
-	return ret
-}
-
-func Rgb8PaletteToGoImage(w, h int, rgb8data []byte, pal color.Palette) image.Image {
-	rect := image.Rectangle{
-		Max: image.Point{
-			X: w,
-			Y: h,
-		},
-	}
-
-	ret := image.NewPaletted(rect, pal)
-
-	for y := 0; y < h; y += 1 {
-		for x := 0; x < w; x += 1 {
-			ret.SetColorIndex(x, y, rgb8data[y*w+x])
-		}
-	}
-
-	return ret
-}
-
-func Crush(sourcefile, destfile string, speed int) error {
-
-	fh, err := os.OpenFile(sourcefile, os.O_RDONLY, 0444)
-	if err != nil {
-		return fmt.Errorf("os.OpenFile: %s", err.Error())
-	}
-	defer fh.Close()
-
-	img, err := png.Decode(fh)
-	if err != nil {
-		return fmt.Errorf("png.Decode: %s", err.Error())
-	}
-
-	width := img.Bounds().Max.X
-	height := img.Bounds().Max.Y
-
-	attr, err := imagequant.NewAttributes()
-	if err != nil {
-		return fmt.Errorf("NewAttributes: %s", err.Error())
-	}
-	defer attr.Release()
-
-	err = attr.SetSpeed(speed)
-	if err != nil {
-		return fmt.Errorf("SetSpeed: %s", err.Error())
-	}
-
-	rgba32data := GoImageToRgba32(img)
-
-	iqm, err := imagequant.NewImage(attr, string(rgba32data), width, height, 0)
-	if err != nil {
-		return fmt.Errorf("NewImage: %s", err.Error())
-	}
-	defer iqm.Release()
-
-	res, err := iqm.Quantize(attr)
-	if err != nil {
-		return fmt.Errorf("Quantize: %s", err.Error())
-	}
-	defer res.Release()
-
-	rgb8data, err := res.WriteRemappedImage()
-	if err != nil {
-		return fmt.Errorf("WriteRemappedImage: %s", err.Error())
-	}
-
-	im2 := Rgb8PaletteToGoImage(res.GetImageWidth(), res.GetImageHeight(), rgb8data, res.GetPalette())
-
-	fh2, err := os.OpenFile(destfile, os.O_WRONLY|os.O_CREATE, 0644)
-	if err != nil {
-		return fmt.Errorf("os.OpenFile: %s", err.Error())
-	}
-	defer fh2.Close()
-
-	penc := png.Encoder{
-		CompressionLevel: png.BestCompression,
-	}
-	err = penc.Encode(fh2, im2)
-	if err != nil {
-		return fmt.Errorf("png.Encode: %s", err.Error())
-	}
-
-	return nil
-}
-
-func main() {
-	ShouldDisplayVersion := flag.Bool("Version", false, "")
-	Infile := flag.String("In", "", "Input filename")
-	Outfile := flag.String("Out", "", "Output filename")
-	Speed := flag.Int("Speed", 3, "Speed (1 slowest, 10 fastest)")
-
-	flag.Parse()
-
-	if *ShouldDisplayVersion {
-		fmt.Printf("libimagequant '%s' (%d)\n", imagequant.GetLibraryVersionString(), imagequant.GetLibraryVersion())
-		os.Exit(1)
-	}
-
-	err := Crush(*Infile, *Outfile, *Speed)
-	if err != nil {
-		fmt.Println(err.Error())
-		os.Exit(1)
-	}
-
-	os.Exit(0)
-}

vendor/code.ivysaur.me/imagequant/imagequant.go

@@ -1,74 +0,0 @@
-/*
-Copyright (c) 2016, The go-imagequant author(s)
-
-Permission to use, copy, modify, and/or distribute this software for any purpose
-with or without fee is hereby granted, provided that the above copyright notice
-and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD TO
-THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
-IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
-CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
-OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
-ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
-SOFTWARE.
-*/
-
-package imagequant
-
-import (
-	"errors"
-)
-
-/*
-#include "libimagequant.h"
-
-const char* liqVersionString() {
-	return LIQ_VERSION_STRING;
-}
-
-*/
-import "C"
-
-var (
-	ErrQualityTooLow      = errors.New("Quality too low")
-	ErrValueOutOfRange    = errors.New("Value out of range")
-	ErrOutOfMemory        = errors.New("Out of memory")
-	ErrAborted            = errors.New("Aborted")
-	ErrBitmapNotAvailable = errors.New("Bitmap not available")
-	ErrBufferTooSmall     = errors.New("Buffer too small")
-	ErrInvalidPointer     = errors.New("Invalid pointer")
-
-	ErrUseAfterFree = errors.New("Use after free")
-)
-
-func translateError(iqe C.liq_error) error {
-	switch iqe {
-	case C.LIQ_OK:
-		return nil
-	case (C.LIQ_QUALITY_TOO_LOW):
-		return ErrQualityTooLow
-	case (C.LIQ_VALUE_OUT_OF_RANGE):
-		return ErrValueOutOfRange
-	case (C.LIQ_OUT_OF_MEMORY):
-		return ErrOutOfMemory
-	case (C.LIQ_ABORTED):
-		return ErrAborted
-	case (C.LIQ_BITMAP_NOT_AVAILABLE):
-		return ErrBitmapNotAvailable
-	case (C.LIQ_BUFFER_TOO_SMALL):
-		return ErrBufferTooSmall
-	case (C.LIQ_INVALID_POINTER):
-		return ErrInvalidPointer
-	default:
-		return errors.New("Unknown error")
-	}
-}
-
-func GetLibraryVersion() int {
-	return int(C.liq_version())
-}
-
-func GetLibraryVersionString() string {
-	return C.GoString(C.liqVersionString())
-}

vendor/code.ivysaur.me/imagequant/kmeans.c

@@ -1,107 +0,0 @@
-/*
-© 2011-2016 by Kornel Lesiński.
-
-This file is part of libimagequant.
-
-libimagequant is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-libimagequant is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with libimagequant. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "libimagequant.h"
-#include "pam.h"
-#include "kmeans.h"
-#include "nearest.h"
-#include <stdlib.h>
-#include <string.h>
-
-#ifdef _OPENMP
-#include <omp.h>
-#else
-#define omp_get_max_threads() 1
-#define omp_get_thread_num() 0
-#endif
-
-/*
- * K-Means iteration: new palette color is computed from weighted average of colors that map to that palette entry.
- */
-LIQ_PRIVATE void kmeans_init(const colormap *map, const unsigned int max_threads, kmeans_state average_color[])
-{
-    memset(average_color, 0, sizeof(average_color[0])*(KMEANS_CACHE_LINE_GAP+map->colors)*max_threads);
-}
-
-LIQ_PRIVATE void kmeans_update_color(const f_pixel acolor, const float value, const colormap *map, unsigned int match, const unsigned int thread, kmeans_state average_color[])
-{
-    match += thread * (KMEANS_CACHE_LINE_GAP+map->colors);
-    average_color[match].a += acolor.a * value;
-    average_color[match].r += acolor.r * value;
-    average_color[match].g += acolor.g * value;
-    average_color[match].b += acolor.b * value;
-    average_color[match].total += value;
-}
-
-LIQ_PRIVATE void kmeans_finalize(colormap *map, const unsigned int max_threads, const kmeans_state average_color[])
-{
-    for (unsigned int i=0; i < map->colors; i++) {
-        double a=0, r=0, g=0, b=0, total=0;
-
-        // Aggregate results from all threads
-        for(unsigned int t=0; t < max_threads; t++) {
-            const unsigned int offset = (KMEANS_CACHE_LINE_GAP+map->colors) * t + i;
-
-            a += average_color[offset].a;
-            r += average_color[offset].r;
-            g += average_color[offset].g;
-            b += average_color[offset].b;
-            total += average_color[offset].total;
-        }
-
-        if (total && !map->palette[i].fixed) {
-            map->palette[i].acolor = (f_pixel){
-                .a = a / total,
-                .r = r / total,
-                .g = g / total,
-                .b = b / total,
-            };
-            map->palette[i].popularity = total;
-        }
-    }
-}
-
-LIQ_PRIVATE double kmeans_do_iteration(histogram *hist, colormap *const map, kmeans_callback callback)
-{
-    const unsigned int max_threads = omp_get_max_threads();
-    kmeans_state average_color[(KMEANS_CACHE_LINE_GAP+map->colors) * max_threads];
-    kmeans_init(map, max_threads, average_color);
-    struct nearest_map *const n = nearest_init(map);
-    hist_item *const achv = hist->achv;
-    const int hist_size = hist->size;
-
-    double total_diff=0;
-    #pragma omp parallel for if (hist_size > 3000) \
-        schedule(static) default(none) shared(average_color,callback) reduction(+:total_diff)
-    for(int j=0; j < hist_size; j++) {
-        float diff;
-        unsigned int match = nearest_search(n, &achv[j].acolor, achv[j].tmp.likely_colormap_index, &diff);
-        achv[j].tmp.likely_colormap_index = match;
-        total_diff += diff * achv[j].perceptual_weight;
-
-        kmeans_update_color(achv[j].acolor, achv[j].perceptual_weight, map, match, omp_get_thread_num(), average_color);
-
-        if (callback) callback(&achv[j], diff);
-    }
-
-    nearest_free(n);
-    kmeans_finalize(map, max_threads, average_color);
-
-    return total_diff / hist->total_perceptual_weight;
-}

vendor/code.ivysaur.me/imagequant/kmeans.h

@@ -1,19 +0,0 @@
-
-#ifndef KMEANS_H
-#define KMEANS_H
-
-// Spread memory touched by different threads at least 64B apart which I assume is the cache line size. This should avoid memory write contention.
-#define KMEANS_CACHE_LINE_GAP ((64+sizeof(kmeans_state)-1)/sizeof(kmeans_state))
-
-typedef struct {
-    double a, r, g, b, total;
-} kmeans_state;
-
-typedef void (*kmeans_callback)(hist_item *item, float diff);
-
-LIQ_PRIVATE void kmeans_init(const colormap *map, const unsigned int max_threads, kmeans_state state[]);
-LIQ_PRIVATE void kmeans_update_color(const f_pixel acolor, const float value, const colormap *map, unsigned int match, const unsigned int thread, kmeans_state average_color[]);
-LIQ_PRIVATE void kmeans_finalize(colormap *map, const unsigned int max_threads, const kmeans_state state[]);
-LIQ_PRIVATE double kmeans_do_iteration(histogram *hist, colormap *const map, kmeans_callback callback);
-
-#endif

vendor/code.ivysaur.me/imagequant/libimagequant.h

@@ -1,144 +0,0 @@
-/*
- * https://pngquant.org
- */
-
-#ifndef LIBIMAGEQUANT_H
-#define LIBIMAGEQUANT_H
-
-#ifdef IMAGEQUANT_EXPORTS
-#define LIQ_EXPORT __declspec(dllexport)
-#endif
-
-#ifndef LIQ_EXPORT
-#define LIQ_EXPORT extern
-#endif
-
-#define LIQ_VERSION 20900
-#define LIQ_VERSION_STRING "2.9.0"
-
-#ifndef LIQ_PRIVATE
-#if defined(__GNUC__) || defined (__llvm__)
-#define LIQ_PRIVATE __attribute__((visibility("hidden")))
-#define LIQ_NONNULL __attribute__((nonnull))
-#define LIQ_USERESULT __attribute__((warn_unused_result))
-#else
-#define LIQ_PRIVATE
-#define LIQ_NONNULL
-#define LIQ_USERESULT
-#endif
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stddef.h>
-
-typedef struct liq_attr liq_attr;
-typedef struct liq_image liq_image;
-typedef struct liq_result liq_result;
-typedef struct liq_histogram liq_histogram;
-
-typedef struct liq_color {
-    unsigned char r, g, b, a;
-} liq_color;
-
-typedef struct liq_palette {
-    unsigned int count;
-    liq_color entries[256];
-} liq_palette;
-
-typedef enum liq_error {
-    LIQ_OK = 0,
-    LIQ_QUALITY_TOO_LOW = 99,
-    LIQ_VALUE_OUT_OF_RANGE = 100,
-    LIQ_OUT_OF_MEMORY,
-    LIQ_ABORTED,
-    LIQ_BITMAP_NOT_AVAILABLE,
-    LIQ_BUFFER_TOO_SMALL,
-    LIQ_INVALID_POINTER,
-    LIQ_UNSUPPORTED,
-} liq_error;
-
-enum liq_ownership {LIQ_OWN_ROWS=4, LIQ_OWN_PIXELS=8};
-
-typedef struct liq_histogram_entry {
-    liq_color color;
-    unsigned int count;
-} liq_histogram_entry;
-
-LIQ_EXPORT LIQ_USERESULT liq_attr* liq_attr_create(void);
-LIQ_EXPORT LIQ_USERESULT liq_attr* liq_attr_create_with_allocator(void* (*malloc)(size_t), void (*free)(void*));
-LIQ_EXPORT LIQ_USERESULT liq_attr* liq_attr_copy(const liq_attr *orig) LIQ_NONNULL;
-LIQ_EXPORT void liq_attr_destroy(liq_attr *attr) LIQ_NONNULL;
-
-LIQ_EXPORT LIQ_USERESULT liq_histogram* liq_histogram_create(const liq_attr* attr);
-LIQ_EXPORT liq_error liq_histogram_add_image(liq_histogram *hist, const liq_attr *attr, liq_image* image) LIQ_NONNULL;
-LIQ_EXPORT liq_error liq_histogram_add_colors(liq_histogram *hist, const liq_attr *attr, const liq_histogram_entry entries[], int num_entries, double gamma) LIQ_NONNULL;
-LIQ_EXPORT void liq_histogram_destroy(liq_histogram *hist) LIQ_NONNULL;
-
-LIQ_EXPORT liq_error liq_set_max_colors(liq_attr* attr, int colors) LIQ_NONNULL;
-LIQ_EXPORT LIQ_USERESULT int liq_get_max_colors(const liq_attr* attr) LIQ_NONNULL;
-LIQ_EXPORT liq_error liq_set_speed(liq_attr* attr, int speed) LIQ_NONNULL;
-LIQ_EXPORT LIQ_USERESULT int liq_get_speed(const liq_attr* attr) LIQ_NONNULL;
-LIQ_EXPORT liq_error liq_set_min_opacity(liq_attr* attr, int min) LIQ_NONNULL;
-LIQ_EXPORT LIQ_USERESULT int liq_get_min_opacity(const liq_attr* attr) LIQ_NONNULL;
-LIQ_EXPORT liq_error liq_set_min_posterization(liq_attr* attr, int bits) LIQ_NONNULL;
-LIQ_EXPORT LIQ_USERESULT int liq_get_min_posterization(const liq_attr* attr) LIQ_NONNULL;
-LIQ_EXPORT liq_error liq_set_quality(liq_attr* attr, int minimum, int maximum) LIQ_NONNULL;
-LIQ_EXPORT LIQ_USERESULT int liq_get_min_quality(const liq_attr* attr) LIQ_NONNULL;
-LIQ_EXPORT LIQ_USERESULT int liq_get_max_quality(const liq_attr* attr) LIQ_NONNULL;
-LIQ_EXPORT void liq_set_last_index_transparent(liq_attr* attr, int is_last) LIQ_NONNULL;
-
-typedef void liq_log_callback_function(const liq_attr*, const char *message, void* user_info);
-typedef void liq_log_flush_callback_function(const liq_attr*, void* user_info);
-LIQ_EXPORT void liq_set_log_callback(liq_attr*, liq_log_callback_function*, void* user_info);
-LIQ_EXPORT void liq_set_log_flush_callback(liq_attr*, liq_log_flush_callback_function*, void* user_info);
-
-typedef int liq_progress_callback_function(float progress_percent, void* user_info);
-LIQ_EXPORT void liq_attr_set_progress_callback(liq_attr*, liq_progress_callback_function*, void* user_info);
-LIQ_EXPORT void liq_result_set_progress_callback(liq_result*, liq_progress_callback_function*, void* user_info);
-
-// The rows and their data are not modified. The type of `rows` is non-const only due to a bug in C's typesystem design.
-LIQ_EXPORT LIQ_USERESULT liq_image *liq_image_create_rgba_rows(const liq_attr *attr, void *const rows[], int width, int height, double gamma) LIQ_NONNULL;
-LIQ_EXPORT LIQ_USERESULT liq_image *liq_image_create_rgba(const liq_attr *attr, const void *bitmap, int width, int height, double gamma) LIQ_NONNULL;
-
-typedef void liq_image_get_rgba_row_callback(liq_color row_out[], int row, int width, void* user_info);
-LIQ_EXPORT LIQ_USERESULT liq_image *liq_image_create_custom(const liq_attr *attr, liq_image_get_rgba_row_callback *row_callback, void* user_info, int width, int height, double gamma);
-
-LIQ_EXPORT liq_error liq_image_set_memory_ownership(liq_image *image, int ownership_flags) LIQ_NONNULL;
-LIQ_EXPORT liq_error liq_image_add_fixed_color(liq_image *img, liq_color color) LIQ_NONNULL;
-LIQ_EXPORT LIQ_USERESULT int liq_image_get_width(const liq_image *img) LIQ_NONNULL;
-LIQ_EXPORT LIQ_USERESULT int liq_image_get_height(const liq_image *img) LIQ_NONNULL;
-LIQ_EXPORT void liq_image_destroy(liq_image *img) LIQ_NONNULL;
-
-LIQ_EXPORT LIQ_USERESULT liq_error liq_histogram_quantize(liq_histogram *const input_hist, liq_attr *const options, liq_result **result_output) LIQ_NONNULL;
-LIQ_EXPORT LIQ_USERESULT liq_error liq_image_quantize(liq_image *const input_image, liq_attr *const options, liq_result **result_output) LIQ_NONNULL;
-
-LIQ_EXPORT liq_error liq_set_dithering_level(liq_result *res, float dither_level) LIQ_NONNULL;
-LIQ_EXPORT liq_error liq_set_output_gamma(liq_result* res, double gamma) LIQ_NONNULL;
-LIQ_EXPORT LIQ_USERESULT double liq_get_output_gamma(const liq_result *result) LIQ_NONNULL;
-
-LIQ_EXPORT LIQ_USERESULT const liq_palette *liq_get_palette(liq_result *result) LIQ_NONNULL;
-
-LIQ_EXPORT liq_error liq_write_remapped_image(liq_result *result, liq_image *input_image, void *buffer, size_t buffer_size) LIQ_NONNULL;
-LIQ_EXPORT liq_error liq_write_remapped_image_rows(liq_result *result, liq_image *input_image, unsigned char **row_pointers) LIQ_NONNULL;
-
-LIQ_EXPORT double liq_get_quantization_error(const liq_result *result) LIQ_NONNULL;
-LIQ_EXPORT int liq_get_quantization_quality(const liq_result *result) LIQ_NONNULL;
-LIQ_EXPORT double liq_get_remapping_error(const liq_result *result) LIQ_NONNULL;
-LIQ_EXPORT int liq_get_remapping_quality(const liq_result *result) LIQ_NONNULL;
-
-LIQ_EXPORT void liq_result_destroy(liq_result *) LIQ_NONNULL;
-
-LIQ_EXPORT int liq_version(void);
-
-
-// Deprecated
-LIQ_EXPORT LIQ_USERESULT liq_result *liq_quantize_image(liq_attr *options, liq_image *input_image) LIQ_NONNULL;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

vendor/code.ivysaur.me/imagequant/mediancut.c

@@ -1,470 +0,0 @@
-/*
-** © 2009-2015 by Kornel Lesiński.
-**
-** This file is part of libimagequant.
-**
-** libimagequant is free software: you can redistribute it and/or modify
-** it under the terms of the GNU General Public License as published by
-** the Free Software Foundation, either version 3 of the License, or
-** (at your option) any later version.
-**
-** libimagequant is distributed in the hope that it will be useful,
-** but WITHOUT ANY WARRANTY; without even the implied warranty of
-** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-** GNU General Public License for more details.
-**
-** You should have received a copy of the GNU General Public License
-** along with libimagequant. If not, see <http://www.gnu.org/licenses/>.
-*/
-/*
-** Copyright (C) 1989, 1991 by Jef Poskanzer.
-** Copyright (C) 1997, 2000, 2002 by Greg Roelofs; based on an idea by
-**                                Stefan Schneider.
-**
-** Permission to use, copy, modify, and distribute this software and its
-** documentation for any purpose and without fee is hereby granted, provided
-** that the above copyright notice appear in all copies and that both that
-** copyright notice and this permission notice appear in supporting
-** documentation.  This software is provided "as is" without express or
-** implied warranty.
-*/
-
-#include <stdlib.h>
-#include <stddef.h>
-
-#include "libimagequant.h"
-#include "pam.h"
-#include "mediancut.h"
-
-#define index_of_channel(ch) (offsetof(f_pixel,ch)/sizeof(float))
-
-static f_pixel averagepixels(unsigned int clrs, const hist_item achv[]);
-
-struct box {
-    f_pixel color;
-    f_pixel variance;
-    double sum, total_error, max_error;
-    unsigned int ind;
-    unsigned int colors;
-};
-
-ALWAYS_INLINE static double variance_diff(double val, const double good_enough);
-inline static double variance_diff(double val, const double good_enough)
-{
-    val *= val;
-    if (val < good_enough*good_enough) return val*0.25;
-    return val;
-}
-
-/** Weighted per-channel variance of the box. It's used to decide which channel to split by */
-static f_pixel box_variance(const hist_item achv[], const struct box *box)
-{
-    f_pixel mean = box->color;
-    double variancea=0, variancer=0, varianceg=0, varianceb=0;
-
-    for(unsigned int i = 0; i < box->colors; ++i) {
-        const f_pixel px = achv[box->ind + i].acolor;
-        double weight = achv[box->ind + i].adjusted_weight;
-        variancea += variance_diff(mean.a - px.a, 2.0/256.0)*weight;
-        variancer += variance_diff(mean.r - px.r, 1.0/256.0)*weight;
-        varianceg += variance_diff(mean.g - px.g, 1.0/256.0)*weight;
-        varianceb += variance_diff(mean.b - px.b, 1.0/256.0)*weight;
-    }
-
-    return (f_pixel){
-        .a = variancea*(4.0/16.0),
-        .r = variancer*(7.0/16.0),
-        .g = varianceg*(9.0/16.0),
-        .b = varianceb*(5.0/16.0),
-    };
-}
-
-static double box_max_error(const hist_item achv[], const struct box *box)
-{
-    f_pixel mean = box->color;
-    double max_error = 0;
-
-    for(unsigned int i = 0; i < box->colors; ++i) {
-        const double diff = colordifference(mean, achv[box->ind + i].acolor);
-        if (diff > max_error) {
-            max_error = diff;
-        }
-    }
-    return max_error;
-}
-
-ALWAYS_INLINE static double color_weight(f_pixel median, hist_item h);
-
-static inline void hist_item_swap(hist_item *l, hist_item *r)
-{
-    if (l != r) {
-        hist_item t = *l;
-        *l = *r;
-        *r = t;
-    }
-}
-
-ALWAYS_INLINE static unsigned int qsort_pivot(const hist_item *const base, const unsigned int len);
-inline static unsigned int qsort_pivot(const hist_item *const base, const unsigned int len)
-{
-    if (len < 32) {
-        return len/2;
-    }
-
-    const unsigned int aidx=8, bidx=len/2, cidx=len-1;
-    const unsigned int a=base[aidx].tmp.sort_value, b=base[bidx].tmp.sort_value, c=base[cidx].tmp.sort_value;
-    return (a < b) ? ((b < c) ? bidx : ((a < c) ? cidx : aidx ))
-           : ((b > c) ? bidx : ((a < c) ? aidx : cidx ));
-}
-
-ALWAYS_INLINE static unsigned int qsort_partition(hist_item *const base, const unsigned int len);
-inline static unsigned int qsort_partition(hist_item *const base, const unsigned int len)
-{
-    unsigned int l = 1, r = len;
-    if (len >= 8) {
-        hist_item_swap(&base[0], &base[qsort_pivot(base,len)]);
-    }
-
-    const unsigned int pivot_value = base[0].tmp.sort_value;
-    while (l < r) {
-        if (base[l].tmp.sort_value >= pivot_value) {
-            l++;
-        } else {
-            while(l < --r && base[r].tmp.sort_value <= pivot_value) {}
-            hist_item_swap(&base[l], &base[r]);
-        }
-    }
-    l--;
-    hist_item_swap(&base[0], &base[l]);
-
-    return l;
-}
-
-/** quick select algorithm */
-static void hist_item_sort_range(hist_item *base, unsigned int len, unsigned int sort_start)
-{
-    for(;;) {
-        const unsigned int l = qsort_partition(base, len), r = l+1;
-
-        if (l > 0 && sort_start < l) {
-            len = l;
-        }
-        else if (r < len && sort_start > r) {
-            base += r; len -= r; sort_start -= r;
-        }
-        else break;
-    }
-}
-
-/** sorts array to make sum of weights lower than halfvar one side, returns edge between <halfvar and >halfvar parts of the set */
-static hist_item *hist_item_sort_halfvar(hist_item *base, unsigned int len, double *const lowervar, const double halfvar)
-{
-    do {
-        const unsigned int l = qsort_partition(base, len), r = l+1;
-
-        // check if sum of left side is smaller than half,
-        // if it is, then it doesn't need to be sorted
-        unsigned int t = 0; double tmpsum = *lowervar;
-        while (t <= l && tmpsum < halfvar) tmpsum += base[t++].color_weight;
-
-        if (tmpsum < halfvar) {
-            *lowervar = tmpsum;
-        } else {
-            if (l > 0) {
-                hist_item *res = hist_item_sort_halfvar(base, l, lowervar, halfvar);
-                if (res) return res;
-            } else {
-                // End of left recursion. This will be executed in order from the first element.
-                *lowervar += base[0].color_weight;
-                if (*lowervar > halfvar) return &base[0];
-            }
-        }
-
-        if (len > r) {
-            base += r; len -= r; // tail-recursive "call"
-        } else {
-            *lowervar += base[r].color_weight;
-            return (*lowervar > halfvar) ? &base[r] : NULL;
-        }
-    } while(1);
-}
-
-static f_pixel get_median(const struct box *b, hist_item achv[]);
-
-typedef struct {
-    unsigned int chan; float variance;
-} channelvariance;
-
-static int comparevariance(const void *ch1, const void *ch2)
-{
-    return ((const channelvariance*)ch1)->variance > ((const channelvariance*)ch2)->variance ? -1 :
-          (((const channelvariance*)ch1)->variance < ((const channelvariance*)ch2)->variance ? 1 : 0);
-}
-
-/** Finds which channels need to be sorted first and preproceses achv for fast sort */
-static double prepare_sort(struct box *b, hist_item achv[])
-{
-    /*
-     ** Sort dimensions by their variance, and then sort colors first by dimension with highest variance
-     */
-    channelvariance channels[4] = {
-        {index_of_channel(a), b->variance.a},
-        {index_of_channel(r), b->variance.r},
-        {index_of_channel(g), b->variance.g},
-        {index_of_channel(b), b->variance.b},
-    };
-
-    qsort(channels, 4, sizeof(channels[0]), comparevariance);
-
-    for(unsigned int i=0; i < b->colors; i++) {
-        const float *chans = (const float *)&achv[b->ind + i].acolor;
-        // Only the first channel really matters. When trying median cut many times
-        // with different histogram weights, I don't want sort randomness to influence outcome.
-        achv[b->ind + i].tmp.sort_value = ((unsigned int)(chans[channels[0].chan]*65535.0)<<16) |
-                                       (unsigned int)((chans[channels[2].chan] + chans[channels[1].chan]/2.0 + chans[channels[3].chan]/4.0)*65535.0);
-    }
-
-    const f_pixel median = get_median(b, achv);
-
-    // box will be split to make color_weight of each side even
-    const unsigned int ind = b->ind, end = ind+b->colors;
-    double totalvar = 0;
-    for(unsigned int j=ind; j < end; j++) totalvar += (achv[j].color_weight = color_weight(median, achv[j]));
-    return totalvar / 2.0;
-}
-
-/** finds median in unsorted set by sorting only minimum required */
-static f_pixel get_median(const struct box *b, hist_item achv[])
-{
-    const unsigned int median_start = (b->colors-1)/2;
-
-    hist_item_sort_range(&(achv[b->ind]), b->colors,
-                         median_start);
-
-    if (b->colors&1) return achv[b->ind + median_start].acolor;
-
-    // technically the second color is not guaranteed to be sorted correctly
-    // but most of the time it is good enough to be useful
-    return averagepixels(2, &achv[b->ind + median_start]);
-}
-
-/*
- ** Find the best splittable box. -1 if no boxes are splittable.
- */
-static int best_splittable_box(struct box* bv, unsigned int boxes, const double max_mse)
-{
-    int bi=-1; double maxsum=0;
-    for(unsigned int i=0; i < boxes; i++) {
-        if (bv[i].colors < 2) {
-            continue;
-        }
-
-        // looks only at max variance, because it's only going to split by it
-        const double cv = MAX(bv[i].variance.r, MAX(bv[i].variance.g,bv[i].variance.b));
-        double thissum = bv[i].sum * MAX(bv[i].variance.a, cv);
-
-        if (bv[i].max_error > max_mse) {
-            thissum = thissum* bv[i].max_error/max_mse;
-        }
-
-        if (thissum > maxsum) {
-            maxsum = thissum;
-            bi = i;
-        }
-    }
-    return bi;
-}
-
-inline static double color_weight(f_pixel median, hist_item h)
-{
-    float diff = colordifference(median, h.acolor);
-    return sqrt(diff) * (sqrt(1.0+h.adjusted_weight)-1.0);
-}
-
-static void set_colormap_from_boxes(colormap *map, struct box* bv, unsigned int boxes, hist_item *achv);
-static void adjust_histogram(hist_item *achv, const struct box* bv, unsigned int boxes);
-
-static double box_error(const struct box *box, const hist_item achv[])
-{
-    f_pixel avg = box->color;
-
-    double total_error=0;
-    for (unsigned int i = 0; i < box->colors; ++i) {
-        total_error += colordifference(avg, achv[box->ind + i].acolor) * achv[box->ind + i].perceptual_weight;
-    }
-
-    return total_error;
-}
-
-
-static bool total_box_error_below_target(double target_mse, struct box bv[], unsigned int boxes, const histogram *hist)
-{
-    target_mse *= hist->total_perceptual_weight;
-    double total_error=0;
-
-    for(unsigned int i=0; i < boxes; i++) {
-        // error is (re)calculated lazily
-        if (bv[i].total_error >= 0) {
-            total_error += bv[i].total_error;
-        }
-        if (total_error > target_mse) return false;
-    }
-
-    for(unsigned int i=0; i < boxes; i++) {
-        if (bv[i].total_error < 0) {
-            bv[i].total_error = box_error(&bv[i], hist->achv);
-            total_error += bv[i].total_error;
-        }
-        if (total_error > target_mse) return false;
-    }
-
-    return true;
-}
-
-static void box_init(struct box *box, const hist_item *achv, const unsigned int ind, const unsigned int colors, const double sum) {
-    box->ind = ind;
-    box->colors = colors;
-    box->sum = sum;
-    box->total_error = -1;
-    box->color = averagepixels(colors, &achv[ind]);
-    box->variance = box_variance(achv, box);
-    box->max_error = box_max_error(achv, box);
-}
-
-/*
- ** Here is the fun part, the median-cut colormap generator.  This is based
- ** on Paul Heckbert's paper, "Color Image Quantization for Frame Buffer
- ** Display," SIGGRAPH 1982 Proceedings, page 297.
- */
-LIQ_PRIVATE colormap *mediancut(histogram *hist, unsigned int newcolors, const double target_mse, const double max_mse, void* (*malloc)(size_t), void (*free)(void*))
-{
-    hist_item *achv = hist->achv;
-    struct box bv[newcolors];
-
-    /*
-     ** Set up the initial box.
-     */
-        double sum = 0;
-    for(unsigned int i=0; i < hist->size; i++) {
-            sum += achv[i].adjusted_weight;
-        }
-    box_init(&bv[0], achv, 0, hist->size, sum);
-
-    unsigned int boxes = 1;
-
-    /*
-     ** Main loop: split boxes until we have enough.
-     */
-    while (boxes < newcolors) {
-
-        // first splits boxes that exceed quality limit (to have colors for things like odd green pixel),
-        // later raises the limit to allow large smooth areas/gradients get colors.
-        const double current_max_mse = max_mse + (boxes/(double)newcolors)*16.0*max_mse;
-        const int bi = best_splittable_box(bv, boxes, current_max_mse);
-        if (bi < 0)
-            break;        /* ran out of colors! */
-
-        unsigned int indx = bv[bi].ind;
-        unsigned int clrs = bv[bi].colors;
-
-        /*
-         Classic implementation tries to get even number of colors or pixels in each subdivision.
-
-         Here, instead of popularity I use (sqrt(popularity)*variance) metric.
-         Each subdivision balances number of pixels (popular colors) and low variance -
-         boxes can be large if they have similar colors. Later boxes with high variance
-         will be more likely to be split.
-
-         Median used as expected value gives much better results than mean.
-         */
-
-        const double halfvar = prepare_sort(&bv[bi], achv);
-        double lowervar=0;
-
-        // hist_item_sort_halfvar sorts and sums lowervar at the same time
-        // returns item to break at …minus one, which does smell like an off-by-one error.
-        hist_item *break_p = hist_item_sort_halfvar(&achv[indx], clrs, &lowervar, halfvar);
-        unsigned int break_at = MIN(clrs-1, break_p - &achv[indx] + 1);
-
-        /*
-         ** Split the box.
-         */
-        double sm = bv[bi].sum;
-        double lowersum = 0;
-        for(unsigned int i=0; i < break_at; i++) lowersum += achv[indx + i].adjusted_weight;
-
-        box_init(&bv[bi], achv, bv[bi].ind, break_at, lowersum);
-        box_init(&bv[boxes], achv, indx + break_at, clrs - break_at, sm - lowersum);
-
-        ++boxes;
-
-        if (total_box_error_below_target(target_mse, bv, boxes, hist)) {
-            break;
-        }
-    }
-
-    colormap *map = pam_colormap(boxes, malloc, free);
-    set_colormap_from_boxes(map, bv, boxes, achv);
-
-    adjust_histogram(achv, bv, boxes);
-
-    return map;
-}
-
-static void set_colormap_from_boxes(colormap *map, struct box* bv, unsigned int boxes, hist_item *achv)
-{
-    /*
-     ** Ok, we've got enough boxes.  Now choose a representative color for
-     ** each box.  There are a number of possible ways to make this choice.
-     ** One would be to choose the center of the box; this ignores any structure
-     ** within the boxes.  Another method would be to average all the colors in
-     ** the box - this is the method specified in Heckbert's paper.
-     */
-
-    for(unsigned int bi = 0; bi < boxes; ++bi) {
-        map->palette[bi].acolor = bv[bi].color;
-
-        /* store total color popularity (perceptual_weight is approximation of it) */
-        map->palette[bi].popularity = 0;
-        for(unsigned int i=bv[bi].ind; i < bv[bi].ind+bv[bi].colors; i++) {
-            map->palette[bi].popularity += achv[i].perceptual_weight;
-        }
-    }
-}
-
-/* increase histogram popularity by difference from the final color (this is used as part of feedback loop) */
-static void adjust_histogram(hist_item *achv, const struct box* bv, unsigned int boxes)
-{
-    for(unsigned int bi = 0; bi < boxes; ++bi) {
-        for(unsigned int i=bv[bi].ind; i < bv[bi].ind+bv[bi].colors; i++) {
-            achv[i].tmp.likely_colormap_index = bi;
-        }
-    }
-}
-
-static f_pixel averagepixels(unsigned int clrs, const hist_item achv[])
-{
-    double r = 0, g = 0, b = 0, a = 0, sum = 0;
-
-    for(unsigned int i = 0; i < clrs; i++) {
-        const f_pixel px = achv[i].acolor;
-        const double weight = achv[i].adjusted_weight;
-
-        sum += weight;
-        a += px.a * weight;
-        r += px.r * weight;
-        g += px.g * weight;
-        b += px.b * weight;
-    }
-
-    if (sum) {
-        a /= sum;
-        r /= sum;
-        g /= sum;
-        b /= sum;
-    }
-
-    assert(!isnan(r) && !isnan(g) && !isnan(b) && !isnan(a));
-
-    return (f_pixel){.r=r, .g=g, .b=b, .a=a};
-}

vendor/code.ivysaur.me/imagequant/mediancut.h

@@ -1,2 +0,0 @@
-
-LIQ_PRIVATE colormap *mediancut(histogram *hist, unsigned int newcolors, const double target_mse, const double max_mse, void* (*malloc)(size_t), void (*free)(void*));

vendor/code.ivysaur.me/imagequant/mempool.c

@@ -1,81 +0,0 @@
-/*
-© 2011-2016 by Kornel Lesiński.
-
-This file is part of libimagequant.
-
-libimagequant is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-libimagequant is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with libimagequant. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "libimagequant.h"
-#include "mempool.h"
-#include <stdlib.h>
-#include <stdint.h>
-#include <assert.h>
-
-#define ALIGN_MASK 15UL
-#define MEMPOOL_RESERVED ((sizeof(struct mempool)+ALIGN_MASK) & ~ALIGN_MASK)
-
-struct mempool {
-    unsigned int used, size;
-    void* (*malloc)(size_t);
-    void (*free)(void*);
-    struct mempool *next;
-};
-LIQ_PRIVATE void* mempool_create(mempool *mptr, const unsigned int size, unsigned int max_size, void* (*malloc)(size_t), void (*free)(void*))
-{
-    if (*mptr && ((*mptr)->used+size) <= (*mptr)->size) {
-        unsigned int prevused = (*mptr)->used;
-        (*mptr)->used += (size+15UL) & ~0xFUL;
-        return ((char*)(*mptr)) + prevused;
-    }
-
-    mempool old = *mptr;
-    if (!max_size) max_size = (1<<17);
-    max_size = size+ALIGN_MASK > max_size ? size+ALIGN_MASK : max_size;
-
-    *mptr = malloc(MEMPOOL_RESERVED + max_size);
-    if (!*mptr) return NULL;
-    **mptr = (struct mempool){
-        .malloc = malloc,
-        .free = free,
-        .size = MEMPOOL_RESERVED + max_size,
-        .used = sizeof(struct mempool),
-        .next = old,
-    };
-    uintptr_t mptr_used_start = (uintptr_t)(*mptr) + (*mptr)->used;
-    (*mptr)->used += (ALIGN_MASK + 1 - (mptr_used_start & ALIGN_MASK)) & ALIGN_MASK; // reserve bytes required to make subsequent allocations aligned
-    assert(!(((uintptr_t)(*mptr) + (*mptr)->used) & ALIGN_MASK));
-
-    return mempool_alloc(mptr, size, size);
-}
-
-LIQ_PRIVATE void* mempool_alloc(mempool *mptr, const unsigned int size, const unsigned int max_size)
-{
-    if (((*mptr)->used+size) <= (*mptr)->size) {
-        unsigned int prevused = (*mptr)->used;
-        (*mptr)->used += (size + ALIGN_MASK) & ~ALIGN_MASK;
-        return ((char*)(*mptr)) + prevused;
-    }
-
-    return mempool_create(mptr, size, max_size, (*mptr)->malloc, (*mptr)->free);
-}
-
-LIQ_PRIVATE void mempool_destroy(mempool m)
-{
-    while (m) {
-        mempool next = m->next;
-        m->free(m);
-        m = next;
-    }
-}

vendor/code.ivysaur.me/imagequant/mempool.h

@@ -1,13 +0,0 @@
-#ifndef MEMPOOL_H
-#define MEMPOOL_H
-
-#include <stddef.h>
-
-struct mempool;
-typedef struct mempool *mempool;
-
-LIQ_PRIVATE void* mempool_create(mempool *mptr, const unsigned int size, unsigned int capacity, void* (*malloc)(size_t), void (*free)(void*));
-LIQ_PRIVATE void* mempool_alloc(mempool *mptr, const unsigned int size, const unsigned int capacity);
-LIQ_PRIVATE void mempool_destroy(mempool m);
-
-#endif

vendor/code.ivysaur.me/imagequant/nearest.c

@@ -1,206 +0,0 @@
-/*
-© 2011-2015 by Kornel Lesiński.
-
-This file is part of libimagequant.
-
-libimagequant is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-libimagequant is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with libimagequant. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "libimagequant.h"
-#include "pam.h"
-#include "nearest.h"
-#include "mempool.h"
-#include <stdlib.h>
-
-typedef struct vp_sort_tmp {
-    float distance_squared;
-    unsigned int idx;
-} vp_sort_tmp;
-
-typedef struct vp_search_tmp {
-    float distance;
-    unsigned int idx;
-    int exclude;
-} vp_search_tmp;
-
-typedef struct vp_node {
-    struct vp_node *near, *far;
-    f_pixel vantage_point;
-    float radius;
-    unsigned int idx;
-} vp_node;
-
-struct nearest_map {
-    vp_node *root;
-    const colormap_item *palette;
-    float nearest_other_color_dist[256];
-    mempool mempool;
-};
-
-static void vp_search_node(const vp_node *node, const f_pixel *const needle, vp_search_tmp *const best_candidate);
-
-static int vp_compare_distance(const void *ap, const void *bp) {
-    float a = ((const vp_sort_tmp*)ap)->distance_squared;
-    float b = ((const vp_sort_tmp*)bp)->distance_squared;
-    return a > b ? 1 : -1;
-}
-
-static void vp_sort_indexes_by_distance(const f_pixel vantage_point, vp_sort_tmp *indexes, int num_indexes, const colormap_item items[]) {
-    for(int i=0; i < num_indexes; i++) {
-        indexes[i].distance_squared = colordifference(vantage_point, items[indexes[i].idx].acolor);
-    }
-    qsort(indexes, num_indexes, sizeof(indexes[0]), vp_compare_distance);
-}
-
-/*
- * Usually it should pick farthest point, but picking most popular point seems to make search quicker anyway
- */
-static int vp_find_best_vantage_point_index(vp_sort_tmp *indexes, int num_indexes, const colormap_item items[]) {
-    int best = 0;
-    float best_popularity = items[indexes[0].idx].popularity;
-    for(int i = 1; i < num_indexes; i++) {
-        if (items[indexes[i].idx].popularity > best_popularity) {
-            best_popularity = items[indexes[i].idx].popularity;
-            best = i;
-        }
-    }
-    return best;
-}
-
-static vp_node *vp_create_node(mempool *m, vp_sort_tmp *indexes, int num_indexes, const colormap_item items[]) {
-    if (num_indexes <= 0) {
-        return NULL;
-    }
-
-    vp_node *node = mempool_alloc(m, sizeof(node[0]), 0);
-
-    if (num_indexes == 1) {
-        *node = (vp_node){
-            .vantage_point = items[indexes[0].idx].acolor,
-            .idx = indexes[0].idx,
-            .radius = MAX_DIFF,
-        };
-        return node;
-    }
-
-    const int ref = vp_find_best_vantage_point_index(indexes, num_indexes, items);
-    const int ref_idx = indexes[ref].idx;
-
-    // Removes the `ref_idx` item from remaining items, because it's included in the current node
-    num_indexes -= 1;
-    indexes[ref] = indexes[num_indexes];
-
-    vp_sort_indexes_by_distance(items[ref_idx].acolor, indexes, num_indexes, items);
-
-    // Remaining items are split by the median distance
-    const int half_idx = num_indexes/2;
-
-    *node = (vp_node){
-        .vantage_point = items[ref_idx].acolor,
-        .idx = ref_idx,
-        .radius = sqrtf(indexes[half_idx].distance_squared),
-    };
-    node->near = vp_create_node(m, indexes, half_idx, items);
-    node->far = vp_create_node(m, &indexes[half_idx], num_indexes - half_idx, items);
-
-    return node;
-}
-
-LIQ_PRIVATE struct nearest_map *nearest_init(const colormap *map) {
-    mempool m = NULL;
-    struct nearest_map *handle = mempool_create(&m, sizeof(handle[0]), sizeof(handle[0]) + sizeof(vp_node)*map->colors+16, map->malloc, map->free);
-
-    vp_sort_tmp indexes[map->colors];
-
-    for(unsigned int i=0; i < map->colors; i++) {
-        indexes[i].idx = i;
-    }
-
-    vp_node *root = vp_create_node(&m, indexes, map->colors, map->palette);
-    *handle = (struct nearest_map){
-        .root = root,
-        .palette = map->palette,
-        .mempool = m,
-    };
-
-    for(unsigned int i=0; i < map->colors; i++) {
-        vp_search_tmp best = {
-            .distance = MAX_DIFF,
-            .exclude = i,
-        };
-        vp_search_node(root, &map->palette[i].acolor, &best);
-        handle->nearest_other_color_dist[i] = best.distance * best.distance / 4.0; // half of squared distance
-    }
-
-    return handle;
-}
-
-static void vp_search_node(const vp_node *node, const f_pixel *const needle, vp_search_tmp *const best_candidate) {
-    do {
-        const float distance = sqrtf(colordifference(node->vantage_point, *needle));
-
-        if (distance < best_candidate->distance && best_candidate->exclude != node->idx) {
-            best_candidate->distance = distance;
-            best_candidate->idx = node->idx;
-        }
-
-        // Recurse towards most likely candidate first to narrow best candidate's distance as soon as possible
-        if (distance < node->radius) {
-            if (node->near) {
-                vp_search_node(node->near, needle, best_candidate);
-            }
-            // The best node (final answer) may be just ouside the radius, but not farther than
-            // the best distance we know so far. The vp_search_node above should have narrowed
-            // best_candidate->distance, so this path is rarely taken.
-            if (node->far && distance >= node->radius - best_candidate->distance) {
-                node = node->far; // Fast tail recursion
-            } else {
-                break;
-            }
-        } else {
-            if (node->far) {
-                vp_search_node(node->far, needle, best_candidate);
-            }
-            if (node->near && distance <= node->radius + best_candidate->distance) {
-                node = node->near; // Fast tail recursion
-            } else {
-                break;
-            }
-        }
-    } while(true);
-}
-
-LIQ_PRIVATE unsigned int nearest_search(const struct nearest_map *handle, const f_pixel *px, const int likely_colormap_index, float *diff) {
-    const float guess_diff = colordifference(handle->palette[likely_colormap_index].acolor, *px);
-    if (guess_diff < handle->nearest_other_color_dist[likely_colormap_index]) {
-        if (diff) *diff = guess_diff;
-        return likely_colormap_index;
-    }
-
-    vp_search_tmp best_candidate = {
-        .distance = sqrtf(guess_diff),
-        .idx = likely_colormap_index,
-        .exclude = -1,
-    };
-    vp_search_node(handle->root, px, &best_candidate);
-    if (diff) {
-        *diff = best_candidate.distance * best_candidate.distance;
-    }
-    return best_candidate.idx;
-}
-
-LIQ_PRIVATE void nearest_free(struct nearest_map *centroids)
-{
-    mempool_destroy(centroids->mempool);
-}

vendor/code.ivysaur.me/imagequant/nearest.h

@@ -1,8 +0,0 @@
-//
-//  nearest.h
-//  pngquant
-//
-struct nearest_map;
-LIQ_PRIVATE struct nearest_map *nearest_init(const colormap *palette);
-LIQ_PRIVATE unsigned int nearest_search(const struct nearest_map *map, const f_pixel *px, const int palette_index_guess, float *diff);
-LIQ_PRIVATE void nearest_free(struct nearest_map *map);

vendor/code.ivysaur.me/imagequant/pam.c

@@ -1,276 +0,0 @@
-/* pam.c - pam (portable alpha map) utility library
-**
-** Copyright (C) 1989, 1991 by Jef Poskanzer.
-** Copyright (C) 1997, 2000, 2002 by Greg Roelofs; based on an idea by
-**                                Stefan Schneider.
-** © 2009-2016 by Kornel Lesinski.
-**
-** Permission to use, copy, modify, and distribute this software and its
-** documentation for any purpose and without fee is hereby granted, provided
-** that the above copyright notice appear in all copies and that both that
-** copyright notice and this permission notice appear in supporting
-** documentation.  This software is provided "as is" without express or
-** implied warranty.
-*/
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "libimagequant.h"
-#include "pam.h"
-#include "mempool.h"
-
-LIQ_PRIVATE bool pam_computeacolorhash(struct acolorhash_table *acht, const rgba_pixel *const pixels[], unsigned int cols, unsigned int rows, const unsigned char *importance_map)
-{
-    const unsigned int ignorebits = acht->ignorebits;
-    const unsigned int channel_mask = 255U>>ignorebits<<ignorebits;
-    const unsigned int channel_hmask = (255U>>ignorebits) ^ 0xFFU;
-    const unsigned int posterize_mask = channel_mask << 24 | channel_mask << 16 | channel_mask << 8 | channel_mask;
-    const unsigned int posterize_high_mask = channel_hmask << 24 | channel_hmask << 16 | channel_hmask << 8 | channel_hmask;
-
-    const unsigned int hash_size = acht->hash_size;
-
-    /* Go through the entire image, building a hash table of colors. */
-    for(unsigned int row = 0; row < rows; ++row) {
-
-        float boost=1.0;
-        for(unsigned int col = 0; col < cols; ++col) {
-            if (importance_map) {
-                boost = 0.5f+ (double)*importance_map++/255.f;
-            }
-
-            // RGBA color is casted to long for easier hasing/comparisons
-            union rgba_as_int px = {pixels[row][col]};
-            unsigned int hash;
-            if (!px.rgba.a) {
-                // "dirty alpha" has different RGBA values that end up being the same fully transparent color
-                px.l=0; hash=0;
-                boost = 10;
-            } else {
-                // mask posterizes all 4 channels in one go
-                px.l = (px.l & posterize_mask) | ((px.l & posterize_high_mask) >> (8-ignorebits));
-                // fancier hashing algorithms didn't improve much
-                hash = px.l % hash_size;
-            }
-
-            if (!pam_add_to_hash(acht, hash, boost, px, row, rows)) {
-                return false;
-            }
-        }
-
-    }
-    acht->cols = cols;
-    acht->rows += rows;
-    return true;
-}
-
-LIQ_PRIVATE bool pam_add_to_hash(struct acolorhash_table *acht, unsigned int hash, float boost, union rgba_as_int px, unsigned int row, unsigned int rows)
-{
-            /* head of the hash function stores first 2 colors inline (achl->used = 1..2),
-               to reduce number of allocations of achl->other_items.
-             */
-            struct acolorhist_arr_head *achl = &acht->buckets[hash];
-            if (achl->inline1.color.l == px.l && achl->used) {
-                achl->inline1.perceptual_weight += boost;
-                return true;
-            }
-            if (achl->used) {
-                if (achl->used > 1) {
-                    if (achl->inline2.color.l == px.l) {
-                        achl->inline2.perceptual_weight += boost;
-                        return true;
-                    }
-                    // other items are stored as an array (which gets reallocated if needed)
-                    struct acolorhist_arr_item *other_items = achl->other_items;
-                    unsigned int i = 0;
-                    for (; i < achl->used-2; i++) {
-                        if (other_items[i].color.l == px.l) {
-                            other_items[i].perceptual_weight += boost;
-                            return true;
-                        }
-                    }
-
-                    // the array was allocated with spare items
-                    if (i < achl->capacity) {
-                        other_items[i] = (struct acolorhist_arr_item){
-                            .color = px,
-                            .perceptual_weight = boost,
-                        };
-                        achl->used++;
-                        ++acht->colors;
-                        return true;
-                    }
-
-                    if (++acht->colors > acht->maxcolors) {
-                        return false;
-                    }
-
-                    struct acolorhist_arr_item *new_items;
-                    unsigned int capacity;
-                    if (!other_items) { // there was no array previously, alloc "small" array
-                        capacity = 8;
-                        if (acht->freestackp <= 0) {
-                            // estimate how many colors are going to be + headroom
-                            const size_t mempool_size = ((acht->rows + rows-row) * 2 * acht->colors / (acht->rows + row + 1) + 1024) * sizeof(struct acolorhist_arr_item);
-                            new_items = mempool_alloc(&acht->mempool, sizeof(struct acolorhist_arr_item)*capacity, mempool_size);
-                        } else {
-                            // freestack stores previously freed (reallocated) arrays that can be reused
-                            // (all pesimistically assumed to be capacity = 8)
-                            new_items = acht->freestack[--acht->freestackp];
-                        }
-                    } else {
-                        const unsigned int stacksize = sizeof(acht->freestack)/sizeof(acht->freestack[0]);
-
-                        // simply reallocs and copies array to larger capacity
-                        capacity = achl->capacity*2 + 16;
-                        if (acht->freestackp < stacksize-1) {
-                            acht->freestack[acht->freestackp++] = other_items;
-                        }
-                        const size_t mempool_size = ((acht->rows + rows-row) * 2 * acht->colors / (acht->rows + row + 1) + 32*capacity) * sizeof(struct acolorhist_arr_item);
-                        new_items = mempool_alloc(&acht->mempool, sizeof(struct acolorhist_arr_item)*capacity, mempool_size);
-                        if (!new_items) return false;
-                        memcpy(new_items, other_items, sizeof(other_items[0])*achl->capacity);
-                    }
-
-                    achl->other_items = new_items;
-                    achl->capacity = capacity;
-                    new_items[i] = (struct acolorhist_arr_item){
-                        .color = px,
-                        .perceptual_weight = boost,
-                    };
-                    achl->used++;
-                } else {
-                    // these are elses for first checks whether first and second inline-stored colors are used
-                    achl->inline2.color.l = px.l;
-                    achl->inline2.perceptual_weight = boost;
-                    achl->used = 2;
-                    ++acht->colors;
-                }
-            } else {
-                achl->inline1.color.l = px.l;
-                achl->inline1.perceptual_weight = boost;
-                achl->used = 1;
-                ++acht->colors;
-            }
-    return true;
-}
-
-LIQ_PRIVATE struct acolorhash_table *pam_allocacolorhash(unsigned int maxcolors, unsigned int surface, unsigned int ignorebits, void* (*malloc)(size_t), void (*free)(void*))
-{
-    const size_t estimated_colors = MIN(maxcolors, surface/(ignorebits + (surface > 512*512 ? 6 : 5)));
-    const size_t hash_size = estimated_colors < 66000 ? 6673 : (estimated_colors < 200000 ? 12011 : 24019);
-
-    mempool m = NULL;
-    const size_t buckets_size = hash_size * sizeof(struct acolorhist_arr_head);
-    const size_t mempool_size = sizeof(struct acolorhash_table) + buckets_size + estimated_colors * sizeof(struct acolorhist_arr_item);
-    struct acolorhash_table *t = mempool_create(&m, sizeof(*t) + buckets_size, mempool_size, malloc, free);
-    if (!t) return NULL;
-    *t = (struct acolorhash_table){
-        .mempool = m,
-        .hash_size = hash_size,
-        .maxcolors = maxcolors,
-        .ignorebits = ignorebits,
-    };
-    memset(t->buckets, 0, buckets_size);
-    return t;
-}
-
-ALWAYS_INLINE static float pam_add_to_hist(const float *gamma_lut, hist_item *achv, unsigned int j, const struct acolorhist_arr_item *entry, const float max_perceptual_weight)
-{
-    achv[j].acolor = rgba_to_f(gamma_lut, entry->color.rgba);
-    const float w = MIN(entry->perceptual_weight, max_perceptual_weight);
-    achv[j].adjusted_weight = achv[j].perceptual_weight = w;
-    return w;
-}
-
-LIQ_PRIVATE histogram *pam_acolorhashtoacolorhist(const struct acolorhash_table *acht, const double gamma, void* (*malloc)(size_t), void (*free)(void*))
-{
-    histogram *hist = malloc(sizeof(hist[0]));
-    if (!hist || !acht) return NULL;
-    *hist = (histogram){
-        .achv = malloc(MAX(1,acht->colors) * sizeof(hist->achv[0])),
-        .size = acht->colors,
-        .free = free,
-        .ignorebits = acht->ignorebits,
-    };
-    if (!hist->achv) return NULL;
-
-    float gamma_lut[256];
-    to_f_set_gamma(gamma_lut, gamma);
-
-    /* Limit perceptual weight to 1/10th of the image surface area to prevent
-       a single color from dominating all others. */
-    float max_perceptual_weight = 0.1f * acht->cols * acht->rows;
-    double total_weight = 0;
-
-    for(unsigned int j=0, i=0; i < acht->hash_size; ++i) {
-        const struct acolorhist_arr_head *const achl = &acht->buckets[i];
-        if (achl->used) {
-            total_weight += pam_add_to_hist(gamma_lut, hist->achv, j++, &achl->inline1, max_perceptual_weight);
-
-            if (achl->used > 1) {
-                total_weight += pam_add_to_hist(gamma_lut, hist->achv, j++, &achl->inline2, max_perceptual_weight);
-
-                for(unsigned int k=0; k < achl->used-2; k++) {
-                    total_weight += pam_add_to_hist(gamma_lut, hist->achv, j++, &achl->other_items[k], max_perceptual_weight);
-                }
-            }
-        }
-    }
-
-    hist->total_perceptual_weight = total_weight;
-    return hist;
-}
-
-
-LIQ_PRIVATE void pam_freeacolorhash(struct acolorhash_table *acht)
-{
-    if (acht) {
-        mempool_destroy(acht->mempool);
-    }
-}
-
-LIQ_PRIVATE void pam_freeacolorhist(histogram *hist)
-{
-    hist->free(hist->achv);
-    hist->free(hist);
-}
-
-LIQ_PRIVATE colormap *pam_colormap(unsigned int colors, void* (*malloc)(size_t), void (*free)(void*))
-{
-    assert(colors > 0 && colors < 65536);
-
-    colormap *map;
-    const size_t colors_size = colors * sizeof(map->palette[0]);
-    map = malloc(sizeof(colormap) + colors_size);
-    if (!map) return NULL;
-    *map = (colormap){
-        .malloc = malloc,
-        .free = free,
-        .colors = colors,
-    };
-    memset(map->palette, 0, colors_size);
-    return map;
-}
-
-LIQ_PRIVATE colormap *pam_duplicate_colormap(colormap *map)
-{
-    colormap *dupe = pam_colormap(map->colors, map->malloc, map->free);
-    for(unsigned int i=0; i < map->colors; i++) {
-        dupe->palette[i] = map->palette[i];
-    }
-    return dupe;
-}
-
-LIQ_PRIVATE void pam_freecolormap(colormap *c)
-{
-    c->free(c);
-}
-
-LIQ_PRIVATE void to_f_set_gamma(float gamma_lut[], const double gamma)
-{
-    for(int i=0; i < 256; i++) {
-        gamma_lut[i] = pow((double)i/255.0, internal_gamma/gamma);
-    }
-}
-

vendor/code.ivysaur.me/imagequant/pam.h

@@ -1,271 +0,0 @@
-/* pam.h - pam (portable alpha map) utility library
- **
- ** Colormap routines.
- **
- ** Copyright (C) 1989, 1991 by Jef Poskanzer.
- ** Copyright (C) 1997 by Greg Roelofs.
- **
- ** Permission to use, copy, modify, and distribute this software and its
- ** documentation for any purpose and without fee is hereby granted, provided
- ** that the above copyright notice appear in all copies and that both that
- ** copyright notice and this permission notice appear in supporting
- ** documentation.  This software is provided "as is" without express or
- ** implied warranty.
- */
-
-#ifndef PAM_H
-#define PAM_H
-
-#include <math.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <stdbool.h>
-
-#ifndef MAX
-#  define MAX(a,b)  ((a) > (b)? (a) : (b))
-#  define MIN(a,b)  ((a) < (b)? (a) : (b))
-#endif
-
-#define MAX_DIFF 1e20
-
-#ifndef USE_SSE
-#  if defined(__SSE__) && (defined(__amd64__) || defined(__X86_64__) || defined(_WIN64) || defined(WIN32) || defined(__WIN32__))
-#    define USE_SSE 1
-#  else
-#    define USE_SSE 0
-#  endif
-#endif
-
-#if USE_SSE
-#  include <xmmintrin.h>
-#  ifdef _MSC_VER
-#    include <intrin.h>
-#    define SSE_ALIGN
-#  else
-#    define SSE_ALIGN __attribute__ ((aligned (16)))
-#    if defined(__i386__) && defined(__PIC__)
-#       define cpuid(func,ax,bx,cx,dx)\
-        __asm__ __volatile__ ( \
-        "push %%ebx\n" \
-        "cpuid\n" \
-        "mov %%ebx, %1\n" \
-        "pop %%ebx\n" \
-        : "=a" (ax), "=r" (bx), "=c" (cx), "=d" (dx) \
-        : "a" (func));
-#    else
-#       define cpuid(func,ax,bx,cx,dx)\
-        __asm__ __volatile__ ("cpuid":\
-        "=a" (ax), "=b" (bx), "=c" (cx), "=d" (dx) : "a" (func));
-#    endif
-#endif
-#else
-#  define SSE_ALIGN
-#endif
-
-#if defined(__GNUC__) || defined (__llvm__)
-#define ALWAYS_INLINE __attribute__((always_inline)) inline
-#define NEVER_INLINE __attribute__ ((noinline))
-#elif defined(_MSC_VER)
-#define inline __inline
-#define restrict __restrict
-#define ALWAYS_INLINE __forceinline
-#define NEVER_INLINE __declspec(noinline)
-#else
-#define ALWAYS_INLINE inline
-#define NEVER_INLINE
-#endif
-
-/* from pam.h */
-
-typedef struct {
-    unsigned char r, g, b, a;
-} rgba_pixel;
-
-typedef struct {
-    float a, r, g, b;
-} SSE_ALIGN f_pixel;
-
-static const double internal_gamma = 0.5499;
-
-LIQ_PRIVATE void to_f_set_gamma(float gamma_lut[], const double gamma);
-
-/**
- Converts 8-bit color to internal gamma and premultiplied alpha.
- (premultiplied color space is much better for blending of semitransparent colors)
- */
-ALWAYS_INLINE static f_pixel rgba_to_f(const float gamma_lut[], const rgba_pixel px);
-inline static f_pixel rgba_to_f(const float gamma_lut[], const rgba_pixel px)
-{
-    float a = px.a/255.f;
-
-    return (f_pixel) {
-        .a = a,
-        .r = gamma_lut[px.r]*a,
-        .g = gamma_lut[px.g]*a,
-        .b = gamma_lut[px.b]*a,
-    };
-}
-
-inline static rgba_pixel f_to_rgb(const float gamma, const f_pixel px)
-{
-    if (px.a < 1.f/256.f) {
-        return (rgba_pixel){0,0,0,0};
-    }
-
-    float r = px.r / px.a,
-          g = px.g / px.a,
-          b = px.b / px.a,
-          a = px.a;
-
-    r = powf(r, gamma/internal_gamma);
-    g = powf(g, gamma/internal_gamma);
-    b = powf(b, gamma/internal_gamma);
-
-    // 256, because numbers are in range 1..255.9999… rounded down
-    r *= 256.f;
-    g *= 256.f;
-    b *= 256.f;
-    a *= 256.f;
-
-    return (rgba_pixel){
-        .r = r>=255.f ? 255 : r,
-        .g = g>=255.f ? 255 : g,
-        .b = b>=255.f ? 255 : b,
-        .a = a>=255.f ? 255 : a,
-    };
-}
-
-ALWAYS_INLINE static double colordifference_ch(const double x, const double y, const double alphas);
-inline static double colordifference_ch(const double x, const double y, const double alphas)
-{
-    // maximum of channel blended on white, and blended on black
-    // premultiplied alpha and backgrounds 0/1 shorten the formula
-    const double black = x-y, white = black+alphas;
-    return MAX(black*black, white*white);
-}
-
-ALWAYS_INLINE static float colordifference_stdc(const f_pixel px, const f_pixel py);
-inline static float colordifference_stdc(const f_pixel px, const f_pixel py)
-{
-    // px_b.rgb = px.rgb + 0*(1-px.a) // blend px on black
-    // px_b.a   = px.a   + 1*(1-px.a)
-    // px_w.rgb = px.rgb + 1*(1-px.a) // blend px on white
-    // px_w.a   = px.a   + 1*(1-px.a)
-
-    // px_b.rgb = px.rgb              // difference same as in opaque RGB
-    // px_b.a   = 1
-    // px_w.rgb = px.rgb - px.a       // difference simplifies to formula below
-    // px_w.a   = 1
-
-    // (px.rgb - px.a) - (py.rgb - py.a)
-    // (px.rgb - py.rgb) + (py.a - px.a)
-
-    const double alphas = py.a-px.a;
-    return colordifference_ch(px.r, py.r, alphas) +
-           colordifference_ch(px.g, py.g, alphas) +
-           colordifference_ch(px.b, py.b, alphas);
-}
-
-ALWAYS_INLINE static float colordifference(f_pixel px, f_pixel py);
-inline static float colordifference(f_pixel px, f_pixel py)
-{
-#if USE_SSE
-    const __m128 vpx = _mm_load_ps((const float*)&px);
-    const __m128 vpy = _mm_load_ps((const float*)&py);
-
-    // y.a - x.a
-    __m128 alphas = _mm_sub_ss(vpy, vpx);
-    alphas = _mm_shuffle_ps(alphas,alphas,0); // copy first to all four
-
-    __m128 onblack = _mm_sub_ps(vpx, vpy); // x - y
-    __m128 onwhite = _mm_add_ps(onblack, alphas); // x - y + (y.a - x.a)
-
-    onblack = _mm_mul_ps(onblack, onblack);
-    onwhite = _mm_mul_ps(onwhite, onwhite);
-    const __m128 max = _mm_max_ps(onwhite, onblack);
-
-    // add rgb, not a
-    const __m128 maxhl = _mm_movehl_ps(max, max);
-    const __m128 tmp = _mm_add_ps(max, maxhl);
-    const __m128 sum = _mm_add_ss(maxhl, _mm_shuffle_ps(tmp, tmp, 1));
-
-    const float res = _mm_cvtss_f32(sum);
-    assert(fabs(res - colordifference_stdc(px,py)) < 0.001);
-    return res;
-#else
-    return colordifference_stdc(px,py);
-#endif
-}
-
-/* from pamcmap.h */
-union rgba_as_int {
-    rgba_pixel rgba;
-    unsigned int l;
-};
-
-typedef struct {
-    f_pixel acolor;
-    float adjusted_weight,   // perceptual weight changed to tweak how mediancut selects colors
-          perceptual_weight; // number of pixels weighted by importance of different areas of the picture
-
-    float color_weight;      // these two change every time histogram subset is sorted
-    union {
-        unsigned int sort_value;
-        unsigned char likely_colormap_index;
-    } tmp;
-} hist_item;
-
-typedef struct {
-    hist_item *achv;
-    void (*free)(void*);
-    double total_perceptual_weight;
-    unsigned int size;
-    unsigned int ignorebits;
-} histogram;
-
-typedef struct {
-    f_pixel acolor;
-    float popularity;
-    bool fixed; // if true it's user-supplied and must not be changed (e.g in K-Means iteration)
-} colormap_item;
-
-typedef struct colormap {
-    unsigned int colors;
-    void* (*malloc)(size_t);
-    void (*free)(void*);
-    colormap_item palette[];
-} colormap;
-
-struct acolorhist_arr_item {
-    union rgba_as_int color;
-    float perceptual_weight;
-};
-
-struct acolorhist_arr_head {
-    struct acolorhist_arr_item inline1, inline2;
-    unsigned int used, capacity;
-    struct acolorhist_arr_item *other_items;
-};
-
-struct acolorhash_table {
-    struct mempool *mempool;
-    unsigned int ignorebits, maxcolors, colors, cols, rows;
-    unsigned int hash_size;
-    unsigned int freestackp;
-    struct acolorhist_arr_item *freestack[512];
-    struct acolorhist_arr_head buckets[];
-};
-
-LIQ_PRIVATE void pam_freeacolorhash(struct acolorhash_table *acht);
-LIQ_PRIVATE struct acolorhash_table *pam_allocacolorhash(unsigned int maxcolors, unsigned int surface, unsigned int ignorebits, void* (*malloc)(size_t), void (*free)(void*));
-LIQ_PRIVATE histogram *pam_acolorhashtoacolorhist(const struct acolorhash_table *acht, const double gamma, void* (*malloc)(size_t), void (*free)(void*));
-LIQ_PRIVATE bool pam_computeacolorhash(struct acolorhash_table *acht, const rgba_pixel *const pixels[], unsigned int cols, unsigned int rows, const unsigned char *importance_map);
-LIQ_PRIVATE bool pam_add_to_hash(struct acolorhash_table *acht, unsigned int hash, float boost, union rgba_as_int px, unsigned int row, unsigned int rows);
-
-LIQ_PRIVATE void pam_freeacolorhist(histogram *h);
-
-LIQ_PRIVATE colormap *pam_colormap(unsigned int colors, void* (*malloc)(size_t), void (*free)(void*));
-LIQ_PRIVATE colormap *pam_duplicate_colormap(colormap *map);
-LIQ_PRIVATE void pam_freecolormap(colormap *c);
-
-#endif

vendor/github.com/hashicorp/golang-lru/.gitignore

@@ -1,23 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-*.test

vendor/github.com/hashicorp/golang-lru/2q.go

@@ -1,223 +0,0 @@
-package lru
-
-import (
-	"fmt"
-	"sync"
-
-	"github.com/hashicorp/golang-lru/simplelru"
-)
-
-const (
-	// Default2QRecentRatio is the ratio of the 2Q cache dedicated
-	// to recently added entries that have only been accessed once.
-	Default2QRecentRatio = 0.25
-
-	// Default2QGhostEntries is the default ratio of ghost
-	// entries kept to track entries recently evicted
-	Default2QGhostEntries = 0.50
-)
-
-// TwoQueueCache is a thread-safe fixed size 2Q cache.
-// 2Q is an enhancement over the standard LRU cache
-// in that it tracks both frequently and recently used
-// entries separately. This avoids a burst in access to new
-// entries from evicting frequently used entries. It adds some
-// additional tracking overhead to the standard LRU cache, and is
-// computationally about 2x the cost, and adds some metadata over
-// head. The ARCCache is similar, but does not require setting any
-// parameters.
-type TwoQueueCache struct {
-	size       int
-	recentSize int
-
-	recent      simplelru.LRUCache
-	frequent    simplelru.LRUCache
-	recentEvict simplelru.LRUCache
-	lock        sync.RWMutex
-}
-
-// New2Q creates a new TwoQueueCache using the default
-// values for the parameters.
-func New2Q(size int) (*TwoQueueCache, error) {
-	return New2QParams(size, Default2QRecentRatio, Default2QGhostEntries)
-}
-
-// New2QParams creates a new TwoQueueCache using the provided
-// parameter values.
-func New2QParams(size int, recentRatio float64, ghostRatio float64) (*TwoQueueCache, error) {
-	if size <= 0 {
-		return nil, fmt.Errorf("invalid size")
-	}
-	if recentRatio < 0.0 || recentRatio > 1.0 {
-		return nil, fmt.Errorf("invalid recent ratio")
-	}
-	if ghostRatio < 0.0 || ghostRatio > 1.0 {
-		return nil, fmt.Errorf("invalid ghost ratio")
-	}
-
-	// Determine the sub-sizes
-	recentSize := int(float64(size) * recentRatio)
-	evictSize := int(float64(size) * ghostRatio)
-
-	// Allocate the LRUs
-	recent, err := simplelru.NewLRU(size, nil)
-	if err != nil {
-		return nil, err
-	}
-	frequent, err := simplelru.NewLRU(size, nil)
-	if err != nil {
-		return nil, err
-	}
-	recentEvict, err := simplelru.NewLRU(evictSize, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	// Initialize the cache
-	c := &TwoQueueCache{
-		size:        size,
-		recentSize:  recentSize,
-		recent:      recent,
-		frequent:    frequent,
-		recentEvict: recentEvict,
-	}
-	return c, nil
-}
-
-// Get looks up a key's value from the cache.
-func (c *TwoQueueCache) Get(key interface{}) (value interface{}, ok bool) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	// Check if this is a frequent value
-	if val, ok := c.frequent.Get(key); ok {
-		return val, ok
-	}
-
-	// If the value is contained in recent, then we
-	// promote it to frequent
-	if val, ok := c.recent.Peek(key); ok {
-		c.recent.Remove(key)
-		c.frequent.Add(key, val)
-		return val, ok
-	}
-
-	// No hit
-	return nil, false
-}
-
-// Add adds a value to the cache.
-func (c *TwoQueueCache) Add(key, value interface{}) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	// Check if the value is frequently used already,
-	// and just update the value
-	if c.frequent.Contains(key) {
-		c.frequent.Add(key, value)
-		return
-	}
-
-	// Check if the value is recently used, and promote
-	// the value into the frequent list
-	if c.recent.Contains(key) {
-		c.recent.Remove(key)
-		c.frequent.Add(key, value)
-		return
-	}
-
-	// If the value was recently evicted, add it to the
-	// frequently used list
-	if c.recentEvict.Contains(key) {
-		c.ensureSpace(true)
-		c.recentEvict.Remove(key)
-		c.frequent.Add(key, value)
-		return
-	}
-
-	// Add to the recently seen list
-	c.ensureSpace(false)
-	c.recent.Add(key, value)
-	return
-}
-
-// ensureSpace is used to ensure we have space in the cache
-func (c *TwoQueueCache) ensureSpace(recentEvict bool) {
-	// If we have space, nothing to do
-	recentLen := c.recent.Len()
-	freqLen := c.frequent.Len()
-	if recentLen+freqLen < c.size {
-		return
-	}
-
-	// If the recent buffer is larger than
-	// the target, evict from there
-	if recentLen > 0 && (recentLen > c.recentSize || (recentLen == c.recentSize && !recentEvict)) {
-		k, _, _ := c.recent.RemoveOldest()
-		c.recentEvict.Add(k, nil)
-		return
-	}
-
-	// Remove from the frequent list otherwise
-	c.frequent.RemoveOldest()
-}
-
-// Len returns the number of items in the cache.
-func (c *TwoQueueCache) Len() int {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	return c.recent.Len() + c.frequent.Len()
-}
-
-// Keys returns a slice of the keys in the cache.
-// The frequently used keys are first in the returned slice.
-func (c *TwoQueueCache) Keys() []interface{} {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	k1 := c.frequent.Keys()
-	k2 := c.recent.Keys()
-	return append(k1, k2...)
-}
-
-// Remove removes the provided key from the cache.
-func (c *TwoQueueCache) Remove(key interface{}) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	if c.frequent.Remove(key) {
-		return
-	}
-	if c.recent.Remove(key) {
-		return
-	}
-	if c.recentEvict.Remove(key) {
-		return
-	}
-}
-
-// Purge is used to completely clear the cache.
-func (c *TwoQueueCache) Purge() {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	c.recent.Purge()
-	c.frequent.Purge()
-	c.recentEvict.Purge()
-}
-
-// Contains is used to check if the cache contains a key
-// without updating recency or frequency.
-func (c *TwoQueueCache) Contains(key interface{}) bool {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	return c.frequent.Contains(key) || c.recent.Contains(key)
-}
-
-// Peek is used to inspect the cache value of a key
-// without updating recency or frequency.
-func (c *TwoQueueCache) Peek(key interface{}) (value interface{}, ok bool) {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	if val, ok := c.frequent.Peek(key); ok {
-		return val, ok
-	}
-	return c.recent.Peek(key)
-}

vendor/github.com/hashicorp/golang-lru/2q_test.go

@@ -1,306 +0,0 @@
-package lru
-
-import (
-	"math/rand"
-	"testing"
-)
-
-func Benchmark2Q_Rand(b *testing.B) {
-	l, err := New2Q(8192)
-	if err != nil {
-		b.Fatalf("err: %v", err)
-	}
-
-	trace := make([]int64, b.N*2)
-	for i := 0; i < b.N*2; i++ {
-		trace[i] = rand.Int63() % 32768
-	}
-
-	b.ResetTimer()
-
-	var hit, miss int
-	for i := 0; i < 2*b.N; i++ {
-		if i%2 == 0 {
-			l.Add(trace[i], trace[i])
-		} else {
-			_, ok := l.Get(trace[i])
-			if ok {
-				hit++
-			} else {
-				miss++
-			}
-		}
-	}
-	b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(miss))
-}
-
-func Benchmark2Q_Freq(b *testing.B) {
-	l, err := New2Q(8192)
-	if err != nil {
-		b.Fatalf("err: %v", err)
-	}
-
-	trace := make([]int64, b.N*2)
-	for i := 0; i < b.N*2; i++ {
-		if i%2 == 0 {
-			trace[i] = rand.Int63() % 16384
-		} else {
-			trace[i] = rand.Int63() % 32768
-		}
-	}
-
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		l.Add(trace[i], trace[i])
-	}
-	var hit, miss int
-	for i := 0; i < b.N; i++ {
-		_, ok := l.Get(trace[i])
-		if ok {
-			hit++
-		} else {
-			miss++
-		}
-	}
-	b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(miss))
-}
-
-func Test2Q_RandomOps(t *testing.T) {
-	size := 128
-	l, err := New2Q(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	n := 200000
-	for i := 0; i < n; i++ {
-		key := rand.Int63() % 512
-		r := rand.Int63()
-		switch r % 3 {
-		case 0:
-			l.Add(key, key)
-		case 1:
-			l.Get(key)
-		case 2:
-			l.Remove(key)
-		}
-
-		if l.recent.Len()+l.frequent.Len() > size {
-			t.Fatalf("bad: recent: %d freq: %d",
-				l.recent.Len(), l.frequent.Len())
-		}
-	}
-}
-
-func Test2Q_Get_RecentToFrequent(t *testing.T) {
-	l, err := New2Q(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Touch all the entries, should be in t1
-	for i := 0; i < 128; i++ {
-		l.Add(i, i)
-	}
-	if n := l.recent.Len(); n != 128 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Get should upgrade to t2
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("missing: %d", i)
-		}
-	}
-	if n := l.recent.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 128 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Get be from t2
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("missing: %d", i)
-		}
-	}
-	if n := l.recent.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 128 {
-		t.Fatalf("bad: %d", n)
-	}
-}
-
-func Test2Q_Add_RecentToFrequent(t *testing.T) {
-	l, err := New2Q(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Add initially to recent
-	l.Add(1, 1)
-	if n := l.recent.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Add should upgrade to frequent
-	l.Add(1, 1)
-	if n := l.recent.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Add should remain in frequent
-	l.Add(1, 1)
-	if n := l.recent.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-}
-
-func Test2Q_Add_RecentEvict(t *testing.T) {
-	l, err := New2Q(4)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Add 1,2,3,4,5 -> Evict 1
-	l.Add(1, 1)
-	l.Add(2, 2)
-	l.Add(3, 3)
-	l.Add(4, 4)
-	l.Add(5, 5)
-	if n := l.recent.Len(); n != 4 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.recentEvict.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Pull in the recently evicted
-	l.Add(1, 1)
-	if n := l.recent.Len(); n != 3 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.recentEvict.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Add 6, should cause another recent evict
-	l.Add(6, 6)
-	if n := l.recent.Len(); n != 3 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.recentEvict.Len(); n != 2 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.frequent.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-}
-
-func Test2Q(t *testing.T) {
-	l, err := New2Q(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	for i := 0; i < 256; i++ {
-		l.Add(i, i)
-	}
-	if l.Len() != 128 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-
-	for i, k := range l.Keys() {
-		if v, ok := l.Get(k); !ok || v != k || v != i+128 {
-			t.Fatalf("bad key: %v", k)
-		}
-	}
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be evicted")
-		}
-	}
-	for i := 128; i < 256; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("should not be evicted")
-		}
-	}
-	for i := 128; i < 192; i++ {
-		l.Remove(i)
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be deleted")
-		}
-	}
-
-	l.Purge()
-	if l.Len() != 0 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-	if _, ok := l.Get(200); ok {
-		t.Fatalf("should contain nothing")
-	}
-}
-
-// Test that Contains doesn't update recent-ness
-func Test2Q_Contains(t *testing.T) {
-	l, err := New2Q(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if !l.Contains(1) {
-		t.Errorf("1 should be contained")
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("Contains should not have updated recent-ness of 1")
-	}
-}
-
-// Test that Peek doesn't update recent-ness
-func Test2Q_Peek(t *testing.T) {
-	l, err := New2Q(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if v, ok := l.Peek(1); !ok || v != 1 {
-		t.Errorf("1 should be set to 1: %v, %v", v, ok)
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("should not have updated recent-ness of 1")
-	}
-}

vendor/github.com/hashicorp/golang-lru/LICENSE

@@ -1,362 +0,0 @@
-Mozilla Public License, version 2.0
-
-1. Definitions
-
-1.1. "Contributor"
-
-     means each individual or legal entity that creates, contributes to the
-     creation of, or owns Covered Software.
-
-1.2. "Contributor Version"
-
-     means the combination of the Contributions of others (if any) used by a
-     Contributor and that particular Contributor's Contribution.
-
-1.3. "Contribution"
-
-     means Covered Software of a particular Contributor.
-
-1.4. "Covered Software"
-
-     means Source Code Form to which the initial Contributor has attached the
-     notice in Exhibit A, the Executable Form of such Source Code Form, and
-     Modifications of such Source Code Form, in each case including portions
-     thereof.
-
-1.5. "Incompatible With Secondary Licenses"
-     means
-
-     a. that the initial Contributor has attached the notice described in
-        Exhibit B to the Covered Software; or
-
-     b. that the Covered Software was made available under the terms of
-        version 1.1 or earlier of the License, but not also under the terms of
-        a Secondary License.
-
-1.6. "Executable Form"
-
-     means any form of the work other than Source Code Form.
-
-1.7. "Larger Work"
-
-     means a work that combines Covered Software with other material, in a
-     separate file or files, that is not Covered Software.
-
-1.8. "License"
-
-     means this document.
-
-1.9. "Licensable"
-
-     means having the right to grant, to the maximum extent possible, whether
-     at the time of the initial grant or subsequently, any and all of the
-     rights conveyed by this License.
-
-1.10. "Modifications"
-
-     means any of the following:
-
-     a. any file in Source Code Form that results from an addition to,
-        deletion from, or modification of the contents of Covered Software; or
-
-     b. any new file in Source Code Form that contains any Covered Software.
-
-1.11. "Patent Claims" of a Contributor
-
-      means any patent claim(s), including without limitation, method,
-      process, and apparatus claims, in any patent Licensable by such
-      Contributor that would be infringed, but for the grant of the License,
-      by the making, using, selling, offering for sale, having made, import,
-      or transfer of either its Contributions or its Contributor Version.
-
-1.12. "Secondary License"
-
-      means either the GNU General Public License, Version 2.0, the GNU Lesser
-      General Public License, Version 2.1, the GNU Affero General Public
-      License, Version 3.0, or any later versions of those licenses.
-
-1.13. "Source Code Form"
-
-      means the form of the work preferred for making modifications.
-
-1.14. "You" (or "Your")
-
-      means an individual or a legal entity exercising rights under this
-      License. For legal entities, "You" includes any entity that controls, is
-      controlled by, or is under common control with You. For purposes of this
-      definition, "control" means (a) the power, direct or indirect, to cause
-      the direction or management of such entity, whether by contract or
-      otherwise, or (b) ownership of more than fifty percent (50%) of the
-      outstanding shares or beneficial ownership of such entity.
-
-
-2. License Grants and Conditions
-
-2.1. Grants
-
-     Each Contributor hereby grants You a world-wide, royalty-free,
-     non-exclusive license:
-
-     a. under intellectual property rights (other than patent or trademark)
-        Licensable by such Contributor to use, reproduce, make available,
-        modify, display, perform, distribute, and otherwise exploit its
-        Contributions, either on an unmodified basis, with Modifications, or
-        as part of a Larger Work; and
-
-     b. under Patent Claims of such Contributor to make, use, sell, offer for
-        sale, have made, import, and otherwise transfer either its
-        Contributions or its Contributor Version.
-
-2.2. Effective Date
-
-     The licenses granted in Section 2.1 with respect to any Contribution
-     become effective for each Contribution on the date the Contributor first
-     distributes such Contribution.
-
-2.3. Limitations on Grant Scope
-
-     The licenses granted in this Section 2 are the only rights granted under
-     this License. No additional rights or licenses will be implied from the
-     distribution or licensing of Covered Software under this License.
-     Notwithstanding Section 2.1(b) above, no patent license is granted by a
-     Contributor:
-
-     a. for any code that a Contributor has removed from Covered Software; or
-
-     b. for infringements caused by: (i) Your and any other third party's
-        modifications of Covered Software, or (ii) the combination of its
-        Contributions with other software (except as part of its Contributor
-        Version); or
-
-     c. under Patent Claims infringed by Covered Software in the absence of
-        its Contributions.
-
-     This License does not grant any rights in the trademarks, service marks,
-     or logos of any Contributor (except as may be necessary to comply with
-     the notice requirements in Section 3.4).
-
-2.4. Subsequent Licenses
-
-     No Contributor makes additional grants as a result of Your choice to
-     distribute the Covered Software under a subsequent version of this
-     License (see Section 10.2) or under the terms of a Secondary License (if
-     permitted under the terms of Section 3.3).
-
-2.5. Representation
-
-     Each Contributor represents that the Contributor believes its
-     Contributions are its original creation(s) or it has sufficient rights to
-     grant the rights to its Contributions conveyed by this License.
-
-2.6. Fair Use
-
-     This License is not intended to limit any rights You have under
-     applicable copyright doctrines of fair use, fair dealing, or other
-     equivalents.
-
-2.7. Conditions
-
-     Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
-     Section 2.1.
-
-
-3. Responsibilities
-
-3.1. Distribution of Source Form
-
-     All distribution of Covered Software in Source Code Form, including any
-     Modifications that You create or to which You contribute, must be under
-     the terms of this License. You must inform recipients that the Source
-     Code Form of the Covered Software is governed by the terms of this
-     License, and how they can obtain a copy of this License. You may not
-     attempt to alter or restrict the recipients' rights in the Source Code
-     Form.
-
-3.2. Distribution of Executable Form
-
-     If You distribute Covered Software in Executable Form then:
-
-     a. such Covered Software must also be made available in Source Code Form,
-        as described in Section 3.1, and You must inform recipients of the
-        Executable Form how they can obtain a copy of such Source Code Form by
-        reasonable means in a timely manner, at a charge no more than the cost
-        of distribution to the recipient; and
-
-     b. You may distribute such Executable Form under the terms of this
-        License, or sublicense it under different terms, provided that the
-        license for the Executable Form does not attempt to limit or alter the
-        recipients' rights in the Source Code Form under this License.
-
-3.3. Distribution of a Larger Work
-
-     You may create and distribute a Larger Work under terms of Your choice,
-     provided that You also comply with the requirements of this License for
-     the Covered Software. If the Larger Work is a combination of Covered
-     Software with a work governed by one or more Secondary Licenses, and the
-     Covered Software is not Incompatible With Secondary Licenses, this
-     License permits You to additionally distribute such Covered Software
-     under the terms of such Secondary License(s), so that the recipient of
-     the Larger Work may, at their option, further distribute the Covered
-     Software under the terms of either this License or such Secondary
-     License(s).
-
-3.4. Notices
-
-     You may not remove or alter the substance of any license notices
-     (including copyright notices, patent notices, disclaimers of warranty, or
-     limitations of liability) contained within the Source Code Form of the
-     Covered Software, except that You may alter any license notices to the
-     extent required to remedy known factual inaccuracies.
-
-3.5. Application of Additional Terms
-
-     You may choose to offer, and to charge a fee for, warranty, support,
-     indemnity or liability obligations to one or more recipients of Covered
-     Software. However, You may do so only on Your own behalf, and not on
-     behalf of any Contributor. You must make it absolutely clear that any
-     such warranty, support, indemnity, or liability obligation is offered by
-     You alone, and You hereby agree to indemnify every Contributor for any
-     liability incurred by such Contributor as a result of warranty, support,
-     indemnity or liability terms You offer. You may include additional
-     disclaimers of warranty and limitations of liability specific to any
-     jurisdiction.
-
-4. Inability to Comply Due to Statute or Regulation
-
-   If it is impossible for You to comply with any of the terms of this License
-   with respect to some or all of the Covered Software due to statute,
-   judicial order, or regulation then You must: (a) comply with the terms of
-   this License to the maximum extent possible; and (b) describe the
-   limitations and the code they affect. Such description must be placed in a
-   text file included with all distributions of the Covered Software under
-   this License. Except to the extent prohibited by statute or regulation,
-   such description must be sufficiently detailed for a recipient of ordinary
-   skill to be able to understand it.
-
-5. Termination
-
-5.1. The rights granted under this License will terminate automatically if You
-     fail to comply with any of its terms. However, if You become compliant,
-     then the rights granted under this License from a particular Contributor
-     are reinstated (a) provisionally, unless and until such Contributor
-     explicitly and finally terminates Your grants, and (b) on an ongoing
-     basis, if such Contributor fails to notify You of the non-compliance by
-     some reasonable means prior to 60 days after You have come back into
-     compliance. Moreover, Your grants from a particular Contributor are
-     reinstated on an ongoing basis if such Contributor notifies You of the
-     non-compliance by some reasonable means, this is the first time You have
-     received notice of non-compliance with this License from such
-     Contributor, and You become compliant prior to 30 days after Your receipt
-     of the notice.
-
-5.2. If You initiate litigation against any entity by asserting a patent
-     infringement claim (excluding declaratory judgment actions,
-     counter-claims, and cross-claims) alleging that a Contributor Version
-     directly or indirectly infringes any patent, then the rights granted to
-     You by any and all Contributors for the Covered Software under Section
-     2.1 of this License shall terminate.
-
-5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
-     license agreements (excluding distributors and resellers) which have been
-     validly granted by You or Your distributors under this License prior to
-     termination shall survive termination.
-
-6. Disclaimer of Warranty
-
-   Covered Software is provided under this License on an "as is" basis,
-   without warranty of any kind, either expressed, implied, or statutory,
-   including, without limitation, warranties that the Covered Software is free
-   of defects, merchantable, fit for a particular purpose or non-infringing.
-   The entire risk as to the quality and performance of the Covered Software
-   is with You. Should any Covered Software prove defective in any respect,
-   You (not any Contributor) assume the cost of any necessary servicing,
-   repair, or correction. This disclaimer of warranty constitutes an essential
-   part of this License. No use of  any Covered Software is authorized under
-   this License except under this disclaimer.
-
-7. Limitation of Liability
-
-   Under no circumstances and under no legal theory, whether tort (including
-   negligence), contract, or otherwise, shall any Contributor, or anyone who
-   distributes Covered Software as permitted above, be liable to You for any
-   direct, indirect, special, incidental, or consequential damages of any
-   character including, without limitation, damages for lost profits, loss of
-   goodwill, work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses, even if such party shall have been
-   informed of the possibility of such damages. This limitation of liability
-   shall not apply to liability for death or personal injury resulting from
-   such party's negligence to the extent applicable law prohibits such
-   limitation. Some jurisdictions do not allow the exclusion or limitation of
-   incidental or consequential damages, so this exclusion and limitation may
-   not apply to You.
-
-8. Litigation
-
-   Any litigation relating to this License may be brought only in the courts
-   of a jurisdiction where the defendant maintains its principal place of
-   business and such litigation shall be governed by laws of that
-   jurisdiction, without reference to its conflict-of-law provisions. Nothing
-   in this Section shall prevent a party's ability to bring cross-claims or
-   counter-claims.
-
-9. Miscellaneous
-
-   This License represents the complete agreement concerning the subject
-   matter hereof. If any provision of this License is held to be
-   unenforceable, such provision shall be reformed only to the extent
-   necessary to make it enforceable. Any law or regulation which provides that
-   the language of a contract shall be construed against the drafter shall not
-   be used to construe this License against a Contributor.
-
-
-10. Versions of the License
-
-10.1. New Versions
-
-      Mozilla Foundation is the license steward. Except as provided in Section
-      10.3, no one other than the license steward has the right to modify or
-      publish new versions of this License. Each version will be given a
-      distinguishing version number.
-
-10.2. Effect of New Versions
-
-      You may distribute the Covered Software under the terms of the version
-      of the License under which You originally received the Covered Software,
-      or under the terms of any subsequent version published by the license
-      steward.
-
-10.3. Modified Versions
-
-      If you create software not governed by this License, and you want to
-      create a new license for such software, you may create and use a
-      modified version of this License if you rename the license and remove
-      any references to the name of the license steward (except to note that
-      such modified license differs from this License).
-
-10.4. Distributing Source Code Form that is Incompatible With Secondary
-      Licenses If You choose to distribute Source Code Form that is
-      Incompatible With Secondary Licenses under the terms of this version of
-      the License, the notice described in Exhibit B of this License must be
-      attached.
-
-Exhibit A - Source Code Form License Notice
-
-      This Source Code Form is subject to the
-      terms of the Mozilla Public License, v.
-      2.0. If a copy of the MPL was not
-      distributed with this file, You can
-      obtain one at
-      http://mozilla.org/MPL/2.0/.
-
-If it is not possible or desirable to put the notice in a particular file,
-then You may include the notice in a location (such as a LICENSE file in a
-relevant directory) where a recipient would be likely to look for such a
-notice.
-
-You may add additional accurate notices of copyright ownership.
-
-Exhibit B - "Incompatible With Secondary Licenses" Notice
-
-      This Source Code Form is "Incompatible
-      With Secondary Licenses", as defined by
-      the Mozilla Public License, v. 2.0.

vendor/github.com/hashicorp/golang-lru/README.md

@@ -1,25 +0,0 @@
-golang-lru
-==========
-
-This provides the `lru` package which implements a fixed-size
-thread safe LRU cache. It is based on the cache in Groupcache.
-
-Documentation
-=============
-
-Full docs are available on [Godoc](http://godoc.org/github.com/hashicorp/golang-lru)
-
-Example
-=======
-
-Using the LRU is very simple:
-
-```go
-l, _ := New(128)
-for i := 0; i < 256; i++ {
-    l.Add(i, nil)
-}
-if l.Len() != 128 {
-    panic(fmt.Sprintf("bad len: %v", l.Len()))
-}
-```

vendor/github.com/hashicorp/golang-lru/arc.go

@@ -1,257 +0,0 @@
-package lru
-
-import (
-	"sync"
-
-	"github.com/hashicorp/golang-lru/simplelru"
-)
-
-// ARCCache is a thread-safe fixed size Adaptive Replacement Cache (ARC).
-// ARC is an enhancement over the standard LRU cache in that tracks both
-// frequency and recency of use. This avoids a burst in access to new
-// entries from evicting the frequently used older entries. It adds some
-// additional tracking overhead to a standard LRU cache, computationally
-// it is roughly 2x the cost, and the extra memory overhead is linear
-// with the size of the cache. ARC has been patented by IBM, but is
-// similar to the TwoQueueCache (2Q) which requires setting parameters.
-type ARCCache struct {
-	size int // Size is the total capacity of the cache
-	p    int // P is the dynamic preference towards T1 or T2
-
-	t1 simplelru.LRUCache // T1 is the LRU for recently accessed items
-	b1 simplelru.LRUCache // B1 is the LRU for evictions from t1
-
-	t2 simplelru.LRUCache // T2 is the LRU for frequently accessed items
-	b2 simplelru.LRUCache // B2 is the LRU for evictions from t2
-
-	lock sync.RWMutex
-}
-
-// NewARC creates an ARC of the given size
-func NewARC(size int) (*ARCCache, error) {
-	// Create the sub LRUs
-	b1, err := simplelru.NewLRU(size, nil)
-	if err != nil {
-		return nil, err
-	}
-	b2, err := simplelru.NewLRU(size, nil)
-	if err != nil {
-		return nil, err
-	}
-	t1, err := simplelru.NewLRU(size, nil)
-	if err != nil {
-		return nil, err
-	}
-	t2, err := simplelru.NewLRU(size, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	// Initialize the ARC
-	c := &ARCCache{
-		size: size,
-		p:    0,
-		t1:   t1,
-		b1:   b1,
-		t2:   t2,
-		b2:   b2,
-	}
-	return c, nil
-}
-
-// Get looks up a key's value from the cache.
-func (c *ARCCache) Get(key interface{}) (value interface{}, ok bool) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	// If the value is contained in T1 (recent), then
-	// promote it to T2 (frequent)
-	if val, ok := c.t1.Peek(key); ok {
-		c.t1.Remove(key)
-		c.t2.Add(key, val)
-		return val, ok
-	}
-
-	// Check if the value is contained in T2 (frequent)
-	if val, ok := c.t2.Get(key); ok {
-		return val, ok
-	}
-
-	// No hit
-	return nil, false
-}
-
-// Add adds a value to the cache.
-func (c *ARCCache) Add(key, value interface{}) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	// Check if the value is contained in T1 (recent), and potentially
-	// promote it to frequent T2
-	if c.t1.Contains(key) {
-		c.t1.Remove(key)
-		c.t2.Add(key, value)
-		return
-	}
-
-	// Check if the value is already in T2 (frequent) and update it
-	if c.t2.Contains(key) {
-		c.t2.Add(key, value)
-		return
-	}
-
-	// Check if this value was recently evicted as part of the
-	// recently used list
-	if c.b1.Contains(key) {
-		// T1 set is too small, increase P appropriately
-		delta := 1
-		b1Len := c.b1.Len()
-		b2Len := c.b2.Len()
-		if b2Len > b1Len {
-			delta = b2Len / b1Len
-		}
-		if c.p+delta >= c.size {
-			c.p = c.size
-		} else {
-			c.p += delta
-		}
-
-		// Potentially need to make room in the cache
-		if c.t1.Len()+c.t2.Len() >= c.size {
-			c.replace(false)
-		}
-
-		// Remove from B1
-		c.b1.Remove(key)
-
-		// Add the key to the frequently used list
-		c.t2.Add(key, value)
-		return
-	}
-
-	// Check if this value was recently evicted as part of the
-	// frequently used list
-	if c.b2.Contains(key) {
-		// T2 set is too small, decrease P appropriately
-		delta := 1
-		b1Len := c.b1.Len()
-		b2Len := c.b2.Len()
-		if b1Len > b2Len {
-			delta = b1Len / b2Len
-		}
-		if delta >= c.p {
-			c.p = 0
-		} else {
-			c.p -= delta
-		}
-
-		// Potentially need to make room in the cache
-		if c.t1.Len()+c.t2.Len() >= c.size {
-			c.replace(true)
-		}
-
-		// Remove from B2
-		c.b2.Remove(key)
-
-		// Add the key to the frequently used list
-		c.t2.Add(key, value)
-		return
-	}
-
-	// Potentially need to make room in the cache
-	if c.t1.Len()+c.t2.Len() >= c.size {
-		c.replace(false)
-	}
-
-	// Keep the size of the ghost buffers trim
-	if c.b1.Len() > c.size-c.p {
-		c.b1.RemoveOldest()
-	}
-	if c.b2.Len() > c.p {
-		c.b2.RemoveOldest()
-	}
-
-	// Add to the recently seen list
-	c.t1.Add(key, value)
-	return
-}
-
-// replace is used to adaptively evict from either T1 or T2
-// based on the current learned value of P
-func (c *ARCCache) replace(b2ContainsKey bool) {
-	t1Len := c.t1.Len()
-	if t1Len > 0 && (t1Len > c.p || (t1Len == c.p && b2ContainsKey)) {
-		k, _, ok := c.t1.RemoveOldest()
-		if ok {
-			c.b1.Add(k, nil)
-		}
-	} else {
-		k, _, ok := c.t2.RemoveOldest()
-		if ok {
-			c.b2.Add(k, nil)
-		}
-	}
-}
-
-// Len returns the number of cached entries
-func (c *ARCCache) Len() int {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	return c.t1.Len() + c.t2.Len()
-}
-
-// Keys returns all the cached keys
-func (c *ARCCache) Keys() []interface{} {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	k1 := c.t1.Keys()
-	k2 := c.t2.Keys()
-	return append(k1, k2...)
-}
-
-// Remove is used to purge a key from the cache
-func (c *ARCCache) Remove(key interface{}) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	if c.t1.Remove(key) {
-		return
-	}
-	if c.t2.Remove(key) {
-		return
-	}
-	if c.b1.Remove(key) {
-		return
-	}
-	if c.b2.Remove(key) {
-		return
-	}
-}
-
-// Purge is used to clear the cache
-func (c *ARCCache) Purge() {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	c.t1.Purge()
-	c.t2.Purge()
-	c.b1.Purge()
-	c.b2.Purge()
-}
-
-// Contains is used to check if the cache contains a key
-// without updating recency or frequency.
-func (c *ARCCache) Contains(key interface{}) bool {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	return c.t1.Contains(key) || c.t2.Contains(key)
-}
-
-// Peek is used to inspect the cache value of a key
-// without updating recency or frequency.
-func (c *ARCCache) Peek(key interface{}) (value interface{}, ok bool) {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	if val, ok := c.t1.Peek(key); ok {
-		return val, ok
-	}
-	return c.t2.Peek(key)
-}

vendor/github.com/hashicorp/golang-lru/arc_test.go

@@ -1,377 +0,0 @@
-package lru
-
-import (
-	"math/rand"
-	"testing"
-	"time"
-)
-
-func init() {
-	rand.Seed(time.Now().Unix())
-}
-
-func BenchmarkARC_Rand(b *testing.B) {
-	l, err := NewARC(8192)
-	if err != nil {
-		b.Fatalf("err: %v", err)
-	}
-
-	trace := make([]int64, b.N*2)
-	for i := 0; i < b.N*2; i++ {
-		trace[i] = rand.Int63() % 32768
-	}
-
-	b.ResetTimer()
-
-	var hit, miss int
-	for i := 0; i < 2*b.N; i++ {
-		if i%2 == 0 {
-			l.Add(trace[i], trace[i])
-		} else {
-			_, ok := l.Get(trace[i])
-			if ok {
-				hit++
-			} else {
-				miss++
-			}
-		}
-	}
-	b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(miss))
-}
-
-func BenchmarkARC_Freq(b *testing.B) {
-	l, err := NewARC(8192)
-	if err != nil {
-		b.Fatalf("err: %v", err)
-	}
-
-	trace := make([]int64, b.N*2)
-	for i := 0; i < b.N*2; i++ {
-		if i%2 == 0 {
-			trace[i] = rand.Int63() % 16384
-		} else {
-			trace[i] = rand.Int63() % 32768
-		}
-	}
-
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		l.Add(trace[i], trace[i])
-	}
-	var hit, miss int
-	for i := 0; i < b.N; i++ {
-		_, ok := l.Get(trace[i])
-		if ok {
-			hit++
-		} else {
-			miss++
-		}
-	}
-	b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(miss))
-}
-
-func TestARC_RandomOps(t *testing.T) {
-	size := 128
-	l, err := NewARC(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	n := 200000
-	for i := 0; i < n; i++ {
-		key := rand.Int63() % 512
-		r := rand.Int63()
-		switch r % 3 {
-		case 0:
-			l.Add(key, key)
-		case 1:
-			l.Get(key)
-		case 2:
-			l.Remove(key)
-		}
-
-		if l.t1.Len()+l.t2.Len() > size {
-			t.Fatalf("bad: t1: %d t2: %d b1: %d b2: %d p: %d",
-				l.t1.Len(), l.t2.Len(), l.b1.Len(), l.b2.Len(), l.p)
-		}
-		if l.b1.Len()+l.b2.Len() > size {
-			t.Fatalf("bad: t1: %d t2: %d b1: %d b2: %d p: %d",
-				l.t1.Len(), l.t2.Len(), l.b1.Len(), l.b2.Len(), l.p)
-		}
-	}
-}
-
-func TestARC_Get_RecentToFrequent(t *testing.T) {
-	l, err := NewARC(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Touch all the entries, should be in t1
-	for i := 0; i < 128; i++ {
-		l.Add(i, i)
-	}
-	if n := l.t1.Len(); n != 128 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Get should upgrade to t2
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("missing: %d", i)
-		}
-	}
-	if n := l.t1.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 128 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Get be from t2
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("missing: %d", i)
-		}
-	}
-	if n := l.t1.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 128 {
-		t.Fatalf("bad: %d", n)
-	}
-}
-
-func TestARC_Add_RecentToFrequent(t *testing.T) {
-	l, err := NewARC(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Add initially to t1
-	l.Add(1, 1)
-	if n := l.t1.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Add should upgrade to t2
-	l.Add(1, 1)
-	if n := l.t1.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Add should remain in t2
-	l.Add(1, 1)
-	if n := l.t1.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-}
-
-func TestARC_Adaptive(t *testing.T) {
-	l, err := NewARC(4)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	// Fill t1
-	for i := 0; i < 4; i++ {
-		l.Add(i, i)
-	}
-	if n := l.t1.Len(); n != 4 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Move to t2
-	l.Get(0)
-	l.Get(1)
-	if n := l.t2.Len(); n != 2 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Evict from t1
-	l.Add(4, 4)
-	if n := l.b1.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Current state
-	// t1 : (MRU) [4, 3] (LRU)
-	// t2 : (MRU) [1, 0] (LRU)
-	// b1 : (MRU) [2] (LRU)
-	// b2 : (MRU) [] (LRU)
-
-	// Add 2, should cause hit on b1
-	l.Add(2, 2)
-	if n := l.b1.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-	if l.p != 1 {
-		t.Fatalf("bad: %d", l.p)
-	}
-	if n := l.t2.Len(); n != 3 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Current state
-	// t1 : (MRU) [4] (LRU)
-	// t2 : (MRU) [2, 1, 0] (LRU)
-	// b1 : (MRU) [3] (LRU)
-	// b2 : (MRU) [] (LRU)
-
-	// Add 4, should migrate to t2
-	l.Add(4, 4)
-	if n := l.t1.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 4 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Current state
-	// t1 : (MRU) [] (LRU)
-	// t2 : (MRU) [4, 2, 1, 0] (LRU)
-	// b1 : (MRU) [3] (LRU)
-	// b2 : (MRU) [] (LRU)
-
-	// Add 4, should evict to b2
-	l.Add(5, 5)
-	if n := l.t1.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 3 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.b2.Len(); n != 1 {
-		t.Fatalf("bad: %d", n)
-	}
-
-	// Current state
-	// t1 : (MRU) [5] (LRU)
-	// t2 : (MRU) [4, 2, 1] (LRU)
-	// b1 : (MRU) [3] (LRU)
-	// b2 : (MRU) [0] (LRU)
-
-	// Add 0, should decrease p
-	l.Add(0, 0)
-	if n := l.t1.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.t2.Len(); n != 4 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.b1.Len(); n != 2 {
-		t.Fatalf("bad: %d", n)
-	}
-	if n := l.b2.Len(); n != 0 {
-		t.Fatalf("bad: %d", n)
-	}
-	if l.p != 0 {
-		t.Fatalf("bad: %d", l.p)
-	}
-
-	// Current state
-	// t1 : (MRU) [] (LRU)
-	// t2 : (MRU) [0, 4, 2, 1] (LRU)
-	// b1 : (MRU) [5, 3] (LRU)
-	// b2 : (MRU) [0] (LRU)
-}
-
-func TestARC(t *testing.T) {
-	l, err := NewARC(128)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	for i := 0; i < 256; i++ {
-		l.Add(i, i)
-	}
-	if l.Len() != 128 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-
-	for i, k := range l.Keys() {
-		if v, ok := l.Get(k); !ok || v != k || v != i+128 {
-			t.Fatalf("bad key: %v", k)
-		}
-	}
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be evicted")
-		}
-	}
-	for i := 128; i < 256; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("should not be evicted")
-		}
-	}
-	for i := 128; i < 192; i++ {
-		l.Remove(i)
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be deleted")
-		}
-	}
-
-	l.Purge()
-	if l.Len() != 0 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-	if _, ok := l.Get(200); ok {
-		t.Fatalf("should contain nothing")
-	}
-}
-
-// Test that Contains doesn't update recent-ness
-func TestARC_Contains(t *testing.T) {
-	l, err := NewARC(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if !l.Contains(1) {
-		t.Errorf("1 should be contained")
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("Contains should not have updated recent-ness of 1")
-	}
-}
-
-// Test that Peek doesn't update recent-ness
-func TestARC_Peek(t *testing.T) {
-	l, err := NewARC(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if v, ok := l.Peek(1); !ok || v != 1 {
-		t.Errorf("1 should be set to 1: %v, %v", v, ok)
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("should not have updated recent-ness of 1")
-	}
-}

vendor/github.com/hashicorp/golang-lru/doc.go

@@ -1,21 +0,0 @@
-// Package lru provides three different LRU caches of varying sophistication.
-//
-// Cache is a simple LRU cache. It is based on the
-// LRU implementation in groupcache:
-// https://github.com/golang/groupcache/tree/master/lru
-//
-// TwoQueueCache tracks frequently used and recently used entries separately.
-// This avoids a burst of accesses from taking out frequently used entries,
-// at the cost of about 2x computational overhead and some extra bookkeeping.
-//
-// ARCCache is an adaptive replacement cache. It tracks recent evictions as
-// well as recent usage in both the frequent and recent caches. Its
-// computational overhead is comparable to TwoQueueCache, but the memory
-// overhead is linear with the size of the cache.
-//
-// ARC has been patented by IBM, so do not use it if that is problematic for
-// your program.
-//
-// All caches in this package take locks while operating, and are therefore
-// thread-safe for consumers.
-package lru

vendor/github.com/hashicorp/golang-lru/lru.go

@@ -1,110 +0,0 @@
-package lru
-
-import (
-	"sync"
-
-	"github.com/hashicorp/golang-lru/simplelru"
-)
-
-// Cache is a thread-safe fixed size LRU cache.
-type Cache struct {
-	lru  simplelru.LRUCache
-	lock sync.RWMutex
-}
-
-// New creates an LRU of the given size.
-func New(size int) (*Cache, error) {
-	return NewWithEvict(size, nil)
-}
-
-// NewWithEvict constructs a fixed size cache with the given eviction
-// callback.
-func NewWithEvict(size int, onEvicted func(key interface{}, value interface{})) (*Cache, error) {
-	lru, err := simplelru.NewLRU(size, simplelru.EvictCallback(onEvicted))
-	if err != nil {
-		return nil, err
-	}
-	c := &Cache{
-		lru: lru,
-	}
-	return c, nil
-}
-
-// Purge is used to completely clear the cache.
-func (c *Cache) Purge() {
-	c.lock.Lock()
-	c.lru.Purge()
-	c.lock.Unlock()
-}
-
-// Add adds a value to the cache.  Returns true if an eviction occurred.
-func (c *Cache) Add(key, value interface{}) (evicted bool) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	return c.lru.Add(key, value)
-}
-
-// Get looks up a key's value from the cache.
-func (c *Cache) Get(key interface{}) (value interface{}, ok bool) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	return c.lru.Get(key)
-}
-
-// Contains checks if a key is in the cache, without updating the
-// recent-ness or deleting it for being stale.
-func (c *Cache) Contains(key interface{}) bool {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	return c.lru.Contains(key)
-}
-
-// Peek returns the key value (or undefined if not found) without updating
-// the "recently used"-ness of the key.
-func (c *Cache) Peek(key interface{}) (value interface{}, ok bool) {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	return c.lru.Peek(key)
-}
-
-// ContainsOrAdd checks if a key is in the cache  without updating the
-// recent-ness or deleting it for being stale,  and if not, adds the value.
-// Returns whether found and whether an eviction occurred.
-func (c *Cache) ContainsOrAdd(key, value interface{}) (ok, evicted bool) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	if c.lru.Contains(key) {
-		return true, false
-	}
-	evicted = c.lru.Add(key, value)
-	return false, evicted
-}
-
-// Remove removes the provided key from the cache.
-func (c *Cache) Remove(key interface{}) {
-	c.lock.Lock()
-	c.lru.Remove(key)
-	c.lock.Unlock()
-}
-
-// RemoveOldest removes the oldest item from the cache.
-func (c *Cache) RemoveOldest() {
-	c.lock.Lock()
-	c.lru.RemoveOldest()
-	c.lock.Unlock()
-}
-
-// Keys returns a slice of the keys in the cache, from oldest to newest.
-func (c *Cache) Keys() []interface{} {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	return c.lru.Keys()
-}
-
-// Len returns the number of items in the cache.
-func (c *Cache) Len() int {
-	c.lock.RLock()
-	defer c.lock.RUnlock()
-	return c.lru.Len()
-}

vendor/github.com/hashicorp/golang-lru/lru_test.go

@@ -1,221 +0,0 @@
-package lru
-
-import (
-	"math/rand"
-	"testing"
-)
-
-func BenchmarkLRU_Rand(b *testing.B) {
-	l, err := New(8192)
-	if err != nil {
-		b.Fatalf("err: %v", err)
-	}
-
-	trace := make([]int64, b.N*2)
-	for i := 0; i < b.N*2; i++ {
-		trace[i] = rand.Int63() % 32768
-	}
-
-	b.ResetTimer()
-
-	var hit, miss int
-	for i := 0; i < 2*b.N; i++ {
-		if i%2 == 0 {
-			l.Add(trace[i], trace[i])
-		} else {
-			_, ok := l.Get(trace[i])
-			if ok {
-				hit++
-			} else {
-				miss++
-			}
-		}
-	}
-	b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(miss))
-}
-
-func BenchmarkLRU_Freq(b *testing.B) {
-	l, err := New(8192)
-	if err != nil {
-		b.Fatalf("err: %v", err)
-	}
-
-	trace := make([]int64, b.N*2)
-	for i := 0; i < b.N*2; i++ {
-		if i%2 == 0 {
-			trace[i] = rand.Int63() % 16384
-		} else {
-			trace[i] = rand.Int63() % 32768
-		}
-	}
-
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		l.Add(trace[i], trace[i])
-	}
-	var hit, miss int
-	for i := 0; i < b.N; i++ {
-		_, ok := l.Get(trace[i])
-		if ok {
-			hit++
-		} else {
-			miss++
-		}
-	}
-	b.Logf("hit: %d miss: %d ratio: %f", hit, miss, float64(hit)/float64(miss))
-}
-
-func TestLRU(t *testing.T) {
-	evictCounter := 0
-	onEvicted := func(k interface{}, v interface{}) {
-		if k != v {
-			t.Fatalf("Evict values not equal (%v!=%v)", k, v)
-		}
-		evictCounter++
-	}
-	l, err := NewWithEvict(128, onEvicted)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	for i := 0; i < 256; i++ {
-		l.Add(i, i)
-	}
-	if l.Len() != 128 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-
-	if evictCounter != 128 {
-		t.Fatalf("bad evict count: %v", evictCounter)
-	}
-
-	for i, k := range l.Keys() {
-		if v, ok := l.Get(k); !ok || v != k || v != i+128 {
-			t.Fatalf("bad key: %v", k)
-		}
-	}
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be evicted")
-		}
-	}
-	for i := 128; i < 256; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("should not be evicted")
-		}
-	}
-	for i := 128; i < 192; i++ {
-		l.Remove(i)
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be deleted")
-		}
-	}
-
-	l.Get(192) // expect 192 to be last key in l.Keys()
-
-	for i, k := range l.Keys() {
-		if (i < 63 && k != i+193) || (i == 63 && k != 192) {
-			t.Fatalf("out of order key: %v", k)
-		}
-	}
-
-	l.Purge()
-	if l.Len() != 0 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-	if _, ok := l.Get(200); ok {
-		t.Fatalf("should contain nothing")
-	}
-}
-
-// test that Add returns true/false if an eviction occurred
-func TestLRUAdd(t *testing.T) {
-	evictCounter := 0
-	onEvicted := func(k interface{}, v interface{}) {
-		evictCounter++
-	}
-
-	l, err := NewWithEvict(1, onEvicted)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	if l.Add(1, 1) == true || evictCounter != 0 {
-		t.Errorf("should not have an eviction")
-	}
-	if l.Add(2, 2) == false || evictCounter != 1 {
-		t.Errorf("should have an eviction")
-	}
-}
-
-// test that Contains doesn't update recent-ness
-func TestLRUContains(t *testing.T) {
-	l, err := New(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if !l.Contains(1) {
-		t.Errorf("1 should be contained")
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("Contains should not have updated recent-ness of 1")
-	}
-}
-
-// test that Contains doesn't update recent-ness
-func TestLRUContainsOrAdd(t *testing.T) {
-	l, err := New(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	contains, evict := l.ContainsOrAdd(1, 1)
-	if !contains {
-		t.Errorf("1 should be contained")
-	}
-	if evict {
-		t.Errorf("nothing should be evicted here")
-	}
-
-	l.Add(3, 3)
-	contains, evict = l.ContainsOrAdd(1, 1)
-	if contains {
-		t.Errorf("1 should not have been contained")
-	}
-	if !evict {
-		t.Errorf("an eviction should have occurred")
-	}
-	if !l.Contains(1) {
-		t.Errorf("now 1 should be contained")
-	}
-}
-
-// test that Peek doesn't update recent-ness
-func TestLRUPeek(t *testing.T) {
-	l, err := New(2)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if v, ok := l.Peek(1); !ok || v != 1 {
-		t.Errorf("1 should be set to 1: %v, %v", v, ok)
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("should not have updated recent-ness of 1")
-	}
-}

vendor/github.com/hashicorp/golang-lru/simplelru/lru.go

@@ -1,161 +0,0 @@
-package simplelru
-
-import (
-	"container/list"
-	"errors"
-)
-
-// EvictCallback is used to get a callback when a cache entry is evicted
-type EvictCallback func(key interface{}, value interface{})
-
-// LRU implements a non-thread safe fixed size LRU cache
-type LRU struct {
-	size      int
-	evictList *list.List
-	items     map[interface{}]*list.Element
-	onEvict   EvictCallback
-}
-
-// entry is used to hold a value in the evictList
-type entry struct {
-	key   interface{}
-	value interface{}
-}
-
-// NewLRU constructs an LRU of the given size
-func NewLRU(size int, onEvict EvictCallback) (*LRU, error) {
-	if size <= 0 {
-		return nil, errors.New("Must provide a positive size")
-	}
-	c := &LRU{
-		size:      size,
-		evictList: list.New(),
-		items:     make(map[interface{}]*list.Element),
-		onEvict:   onEvict,
-	}
-	return c, nil
-}
-
-// Purge is used to completely clear the cache.
-func (c *LRU) Purge() {
-	for k, v := range c.items {
-		if c.onEvict != nil {
-			c.onEvict(k, v.Value.(*entry).value)
-		}
-		delete(c.items, k)
-	}
-	c.evictList.Init()
-}
-
-// Add adds a value to the cache.  Returns true if an eviction occurred.
-func (c *LRU) Add(key, value interface{}) (evicted bool) {
-	// Check for existing item
-	if ent, ok := c.items[key]; ok {
-		c.evictList.MoveToFront(ent)
-		ent.Value.(*entry).value = value
-		return false
-	}
-
-	// Add new item
-	ent := &entry{key, value}
-	entry := c.evictList.PushFront(ent)
-	c.items[key] = entry
-
-	evict := c.evictList.Len() > c.size
-	// Verify size not exceeded
-	if evict {
-		c.removeOldest()
-	}
-	return evict
-}
-
-// Get looks up a key's value from the cache.
-func (c *LRU) Get(key interface{}) (value interface{}, ok bool) {
-	if ent, ok := c.items[key]; ok {
-		c.evictList.MoveToFront(ent)
-		return ent.Value.(*entry).value, true
-	}
-	return
-}
-
-// Contains checks if a key is in the cache, without updating the recent-ness
-// or deleting it for being stale.
-func (c *LRU) Contains(key interface{}) (ok bool) {
-	_, ok = c.items[key]
-	return ok
-}
-
-// Peek returns the key value (or undefined if not found) without updating
-// the "recently used"-ness of the key.
-func (c *LRU) Peek(key interface{}) (value interface{}, ok bool) {
-	var ent *list.Element
-	if ent, ok = c.items[key]; ok {
-		return ent.Value.(*entry).value, true
-	}
-	return nil, ok
-}
-
-// Remove removes the provided key from the cache, returning if the
-// key was contained.
-func (c *LRU) Remove(key interface{}) (present bool) {
-	if ent, ok := c.items[key]; ok {
-		c.removeElement(ent)
-		return true
-	}
-	return false
-}
-
-// RemoveOldest removes the oldest item from the cache.
-func (c *LRU) RemoveOldest() (key interface{}, value interface{}, ok bool) {
-	ent := c.evictList.Back()
-	if ent != nil {
-		c.removeElement(ent)
-		kv := ent.Value.(*entry)
-		return kv.key, kv.value, true
-	}
-	return nil, nil, false
-}
-
-// GetOldest returns the oldest entry
-func (c *LRU) GetOldest() (key interface{}, value interface{}, ok bool) {
-	ent := c.evictList.Back()
-	if ent != nil {
-		kv := ent.Value.(*entry)
-		return kv.key, kv.value, true
-	}
-	return nil, nil, false
-}
-
-// Keys returns a slice of the keys in the cache, from oldest to newest.
-func (c *LRU) Keys() []interface{} {
-	keys := make([]interface{}, len(c.items))
-	i := 0
-	for ent := c.evictList.Back(); ent != nil; ent = ent.Prev() {
-		keys[i] = ent.Value.(*entry).key
-		i++
-	}
-	return keys
-}
-
-// Len returns the number of items in the cache.
-func (c *LRU) Len() int {
-	return c.evictList.Len()
-}
-
-// removeOldest removes the oldest item from the cache.
-func (c *LRU) removeOldest() {
-	ent := c.evictList.Back()
-	if ent != nil {
-		c.removeElement(ent)
-	}
-}
-
-// removeElement is used to remove a given list element from the cache
-func (c *LRU) removeElement(e *list.Element) {
-	c.evictList.Remove(e)
-	kv := e.Value.(*entry)
-	delete(c.items, kv.key)
-	if c.onEvict != nil {
-		c.onEvict(kv.key, kv.value)
-	}
-}

vendor/github.com/hashicorp/golang-lru/simplelru/lru_interface.go

@@ -1,37 +0,0 @@
-package simplelru
-
-
-// LRUCache is the interface for simple LRU cache.
-type LRUCache interface {
-  // Adds a value to the cache, returns true if an eviction occurred and
-  // updates the "recently used"-ness of the key.
-  Add(key, value interface{}) bool
-
-  // Returns key's value from the cache and
-  // updates the "recently used"-ness of the key. #value, isFound
-  Get(key interface{}) (value interface{}, ok bool)
-
-  // Check if a key exsists in cache without updating the recent-ness.
-  Contains(key interface{}) (ok bool)
-
-  // Returns key's value without updating the "recently used"-ness of the key.
-  Peek(key interface{}) (value interface{}, ok bool)
-
-  // Removes a key from the cache.
-  Remove(key interface{}) bool
-
-  // Removes the oldest entry from cache.
-  RemoveOldest() (interface{}, interface{}, bool)
-
-  // Returns the oldest entry from the cache. #key, value, isFound
-  GetOldest() (interface{}, interface{}, bool)
-
-  // Returns a slice of the keys in the cache, from oldest to newest.
-  Keys() []interface{}
-
-  // Returns the number of items in the cache.
-  Len() int
-
-  // Clear all cache entries
-  Purge()
-}

vendor/github.com/hashicorp/golang-lru/simplelru/lru_test.go

@@ -1,167 +0,0 @@
-package simplelru
-
-import "testing"
-
-func TestLRU(t *testing.T) {
-	evictCounter := 0
-	onEvicted := func(k interface{}, v interface{}) {
-		if k != v {
-			t.Fatalf("Evict values not equal (%v!=%v)", k, v)
-		}
-		evictCounter++
-	}
-	l, err := NewLRU(128, onEvicted)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	for i := 0; i < 256; i++ {
-		l.Add(i, i)
-	}
-	if l.Len() != 128 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-
-	if evictCounter != 128 {
-		t.Fatalf("bad evict count: %v", evictCounter)
-	}
-
-	for i, k := range l.Keys() {
-		if v, ok := l.Get(k); !ok || v != k || v != i+128 {
-			t.Fatalf("bad key: %v", k)
-		}
-	}
-	for i := 0; i < 128; i++ {
-		_, ok := l.Get(i)
-		if ok {
-			t.Fatalf("should be evicted")
-		}
-	}
-	for i := 128; i < 256; i++ {
-		_, ok := l.Get(i)
-		if !ok {
-			t.Fatalf("should not be evicted")
-		}
-	}
-	for i := 128; i < 192; i++ {
-		ok := l.Remove(i)
-		if !ok {
-			t.Fatalf("should be contained")
-		}
-		ok = l.Remove(i)
-		if ok {
-			t.Fatalf("should not be contained")
-		}
-		_, ok = l.Get(i)
-		if ok {
-			t.Fatalf("should be deleted")
-		}
-	}
-
-	l.Get(192) // expect 192 to be last key in l.Keys()
-
-	for i, k := range l.Keys() {
-		if (i < 63 && k != i+193) || (i == 63 && k != 192) {
-			t.Fatalf("out of order key: %v", k)
-		}
-	}
-
-	l.Purge()
-	if l.Len() != 0 {
-		t.Fatalf("bad len: %v", l.Len())
-	}
-	if _, ok := l.Get(200); ok {
-		t.Fatalf("should contain nothing")
-	}
-}
-
-func TestLRU_GetOldest_RemoveOldest(t *testing.T) {
-	l, err := NewLRU(128, nil)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	for i := 0; i < 256; i++ {
-		l.Add(i, i)
-	}
-	k, _, ok := l.GetOldest()
-	if !ok {
-		t.Fatalf("missing")
-	}
-	if k.(int) != 128 {
-		t.Fatalf("bad: %v", k)
-	}
-
-	k, _, ok = l.RemoveOldest()
-	if !ok {
-		t.Fatalf("missing")
-	}
-	if k.(int) != 128 {
-		t.Fatalf("bad: %v", k)
-	}
-
-	k, _, ok = l.RemoveOldest()
-	if !ok {
-		t.Fatalf("missing")
-	}
-	if k.(int) != 129 {
-		t.Fatalf("bad: %v", k)
-	}
-}
-
-// Test that Add returns true/false if an eviction occurred
-func TestLRU_Add(t *testing.T) {
-	evictCounter := 0
-	onEvicted := func(k interface{}, v interface{}) {
-		evictCounter++
-	}
-
-	l, err := NewLRU(1, onEvicted)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	if l.Add(1, 1) == true || evictCounter != 0 {
-		t.Errorf("should not have an eviction")
-	}
-	if l.Add(2, 2) == false || evictCounter != 1 {
-		t.Errorf("should have an eviction")
-	}
-}
-
-// Test that Contains doesn't update recent-ness
-func TestLRU_Contains(t *testing.T) {
-	l, err := NewLRU(2, nil)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if !l.Contains(1) {
-		t.Errorf("1 should be contained")
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("Contains should not have updated recent-ness of 1")
-	}
-}
-
-// Test that Peek doesn't update recent-ness
-func TestLRU_Peek(t *testing.T) {
-	l, err := NewLRU(2, nil)
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-
-	l.Add(1, 1)
-	l.Add(2, 2)
-	if v, ok := l.Peek(1); !ok || v != 1 {
-		t.Errorf("1 should be set to 1: %v, %v", v, ok)
-	}
-
-	l.Add(3, 3)
-	if l.Contains(1) {
-		t.Errorf("should not have updated recent-ness of 1")
-	}
-}

vendor/golang.org/x/image/.gitattributes

@@ -1,10 +0,0 @@
-# Treat all files in this repo as binary, with no git magic updating
-# line endings. Windows users contributing to Go will need to use a
-# modern version of git and editors capable of LF line endings.
-#
-# We'll prevent accidental CRLF line endings from entering the repo
-# via the git-review gofmt checks.
-#
-# See golang.org/issue/9281
-
-* -text

vendor/golang.org/x/image/.gitignore

@@ -1,2 +0,0 @@
-# Add no patterns to .hgignore except for files generated by the build.
-last-change

vendor/golang.org/x/image/AUTHORS

@@ -1,3 +0,0 @@
-# This source code refers to The Go Authors for copyright purposes.
-# The master list of authors is in the main Go distribution,
-# visible at http://tip.golang.org/AUTHORS.

vendor/golang.org/x/image/CONTRIBUTING.md

@@ -1,26 +0,0 @@
-# Contributing to Go
-
-Go is an open source project.
-
-It is the work of hundreds of contributors. We appreciate your help!
-
-## Filing issues
-
-When [filing an issue](https://golang.org/issue/new), make sure to answer these five questions:
-
-1.  What version of Go are you using (`go version`)?
-2.  What operating system and processor architecture are you using?
-3.  What did you do?
-4.  What did you expect to see?
-5.  What did you see instead?
-
-General questions should go to the [golang-nuts mailing list](https://groups.google.com/group/golang-nuts) instead of the issue tracker.
-The gophers there will answer or ask you to file an issue if you've tripped over a bug.
-
-## Contributing code
-
-Please read the [Contribution Guidelines](https://golang.org/doc/contribute.html)
-before sending patches.
-
-Unless otherwise noted, the Go source files are distributed under
-the BSD-style license found in the LICENSE file.

vendor/golang.org/x/image/CONTRIBUTORS

@@ -1,3 +0,0 @@
-# This source code was written by the Go contributors.
-# The master list of contributors is in the main Go distribution,
-# visible at http://tip.golang.org/CONTRIBUTORS.

vendor/golang.org/x/image/LICENSE

@@ -1,27 +0,0 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/golang.org/x/image/PATENTS

@@ -1,22 +0,0 @@
-Additional IP Rights Grant (Patents)
-
-"This implementation" means the copyrightable works distributed by
-Google as part of the Go project.
-
-Google hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable (except as stated in this section)
-patent license to make, have made, use, offer to sell, sell, import,
-transfer and otherwise run, modify and propagate the contents of this
-implementation of Go, where such license applies only to those patent
-claims, both currently owned or controlled by Google and acquired in
-the future, licensable by Google that are necessarily infringed by this
-implementation of Go.  This grant does not include claims that would be
-infringed only as a consequence of further modification of this
-implementation.  If you or your agent or exclusive licensee institute or
-order or agree to the institution of patent litigation against any
-entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that this implementation of Go or any code incorporated within this
-implementation of Go constitutes direct or contributory patent
-infringement, or inducement of patent infringement, then any patent
-rights granted to you under this License for this implementation of Go
-shall terminate as of the date such litigation is filed.

vendor/golang.org/x/image/README.md

@@ -1,17 +0,0 @@
-# Go Images
-
-This repository holds supplementary Go image libraries.
-
-## Download/Install
-
-The easiest way to install is to run `go get -u golang.org/x/image/...`. You can
-also manually git clone the repository to `$GOPATH/src/golang.org/x/image`.
-
-## Report Issues / Send Patches
-
-This repository uses Gerrit for code changes. To learn how to submit changes to
-this repository, see https://golang.org/doc/contribute.html.
-
-The main issue tracker for the image repository is located at
-https://github.com/golang/go/issues. Prefix your issue with "x/image:" in the
-subject line, so it is easy to find.

vendor/golang.org/x/image/bmp/reader.go

@@ -1,199 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package bmp implements a BMP image decoder and encoder.
-//
-// The BMP specification is at http://www.digicamsoft.com/bmp/bmp.html.
-package bmp // import "golang.org/x/image/bmp"
-
-import (
-	"errors"
-	"image"
-	"image/color"
-	"io"
-)
-
-// ErrUnsupported means that the input BMP image uses a valid but unsupported
-// feature.
-var ErrUnsupported = errors.New("bmp: unsupported BMP image")
-
-func readUint16(b []byte) uint16 {
-	return uint16(b[0]) | uint16(b[1])<<8
-}
-
-func readUint32(b []byte) uint32 {
-	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
-}
-
-// decodePaletted reads an 8 bit-per-pixel BMP image from r.
-// If topDown is false, the image rows will be read bottom-up.
-func decodePaletted(r io.Reader, c image.Config, topDown bool) (image.Image, error) {
-	paletted := image.NewPaletted(image.Rect(0, 0, c.Width, c.Height), c.ColorModel.(color.Palette))
-	if c.Width == 0 || c.Height == 0 {
-		return paletted, nil
-	}
-	var tmp [4]byte
-	y0, y1, yDelta := c.Height-1, -1, -1
-	if topDown {
-		y0, y1, yDelta = 0, c.Height, +1
-	}
-	for y := y0; y != y1; y += yDelta {
-		p := paletted.Pix[y*paletted.Stride : y*paletted.Stride+c.Width]
-		if _, err := io.ReadFull(r, p); err != nil {
-			return nil, err
-		}
-		// Each row is 4-byte aligned.
-		if c.Width%4 != 0 {
-			_, err := io.ReadFull(r, tmp[:4-c.Width%4])
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-	return paletted, nil
-}
-
-// decodeRGB reads a 24 bit-per-pixel BMP image from r.
-// If topDown is false, the image rows will be read bottom-up.
-func decodeRGB(r io.Reader, c image.Config, topDown bool) (image.Image, error) {
-	rgba := image.NewRGBA(image.Rect(0, 0, c.Width, c.Height))
-	if c.Width == 0 || c.Height == 0 {
-		return rgba, nil
-	}
-	// There are 3 bytes per pixel, and each row is 4-byte aligned.
-	b := make([]byte, (3*c.Width+3)&^3)
-	y0, y1, yDelta := c.Height-1, -1, -1
-	if topDown {
-		y0, y1, yDelta = 0, c.Height, +1
-	}
-	for y := y0; y != y1; y += yDelta {
-		if _, err := io.ReadFull(r, b); err != nil {
-			return nil, err
-		}
-		p := rgba.Pix[y*rgba.Stride : y*rgba.Stride+c.Width*4]
-		for i, j := 0, 0; i < len(p); i, j = i+4, j+3 {
-			// BMP images are stored in BGR order rather than RGB order.
-			p[i+0] = b[j+2]
-			p[i+1] = b[j+1]
-			p[i+2] = b[j+0]
-			p[i+3] = 0xFF
-		}
-	}
-	return rgba, nil
-}
-
-// decodeNRGBA reads a 32 bit-per-pixel BMP image from r.
-// If topDown is false, the image rows will be read bottom-up.
-func decodeNRGBA(r io.Reader, c image.Config, topDown bool) (image.Image, error) {
-	rgba := image.NewNRGBA(image.Rect(0, 0, c.Width, c.Height))
-	if c.Width == 0 || c.Height == 0 {
-		return rgba, nil
-	}
-	y0, y1, yDelta := c.Height-1, -1, -1
-	if topDown {
-		y0, y1, yDelta = 0, c.Height, +1
-	}
-	for y := y0; y != y1; y += yDelta {
-		p := rgba.Pix[y*rgba.Stride : y*rgba.Stride+c.Width*4]
-		if _, err := io.ReadFull(r, p); err != nil {
-			return nil, err
-		}
-		for i := 0; i < len(p); i += 4 {
-			// BMP images are stored in BGRA order rather than RGBA order.
-			p[i+0], p[i+2] = p[i+2], p[i+0]
-		}
-	}
-	return rgba, nil
-}
-
-// Decode reads a BMP image from r and returns it as an image.Image.
-// Limitation: The file must be 8, 24 or 32 bits per pixel.
-func Decode(r io.Reader) (image.Image, error) {
-	c, bpp, topDown, err := decodeConfig(r)
-	if err != nil {
-		return nil, err
-	}
-	switch bpp {
-	case 8:
-		return decodePaletted(r, c, topDown)
-	case 24:
-		return decodeRGB(r, c, topDown)
-	case 32:
-		return decodeNRGBA(r, c, topDown)
-	}
-	panic("unreachable")
-}
-
-// DecodeConfig returns the color model and dimensions of a BMP image without
-// decoding the entire image.
-// Limitation: The file must be 8, 24 or 32 bits per pixel.
-func DecodeConfig(r io.Reader) (image.Config, error) {
-	config, _, _, err := decodeConfig(r)
-	return config, err
-}
-
-func decodeConfig(r io.Reader) (config image.Config, bitsPerPixel int, topDown bool, err error) {
-	// We only support those BMP images that are a BITMAPFILEHEADER
-	// immediately followed by a BITMAPINFOHEADER.
-	const (
-		fileHeaderLen = 14
-		infoHeaderLen = 40
-	)
-	var b [1024]byte
-	if _, err := io.ReadFull(r, b[:fileHeaderLen+infoHeaderLen]); err != nil {
-		return image.Config{}, 0, false, err
-	}
-	if string(b[:2]) != "BM" {
-		return image.Config{}, 0, false, errors.New("bmp: invalid format")
-	}
-	offset := readUint32(b[10:14])
-	if readUint32(b[14:18]) != infoHeaderLen {
-		return image.Config{}, 0, false, ErrUnsupported
-	}
-	width := int(int32(readUint32(b[18:22])))
-	height := int(int32(readUint32(b[22:26])))
-	if height < 0 {
-		height, topDown = -height, true
-	}
-	if width < 0 || height < 0 {
-		return image.Config{}, 0, false, ErrUnsupported
-	}
-	// We only support 1 plane, 8 or 24 bits per pixel and no compression.
-	planes, bpp, compression := readUint16(b[26:28]), readUint16(b[28:30]), readUint32(b[30:34])
-	if planes != 1 || compression != 0 {
-		return image.Config{}, 0, false, ErrUnsupported
-	}
-	switch bpp {
-	case 8:
-		if offset != fileHeaderLen+infoHeaderLen+256*4 {
-			return image.Config{}, 0, false, ErrUnsupported
-		}
-		_, err = io.ReadFull(r, b[:256*4])
-		if err != nil {
-			return image.Config{}, 0, false, err
-		}
-		pcm := make(color.Palette, 256)
-		for i := range pcm {
-			// BMP images are stored in BGR order rather than RGB order.
-			// Every 4th byte is padding.
-			pcm[i] = color.RGBA{b[4*i+2], b[4*i+1], b[4*i+0], 0xFF}
-		}
-		return image.Config{ColorModel: pcm, Width: width, Height: height}, 8, topDown, nil
-	case 24:
-		if offset != fileHeaderLen+infoHeaderLen {
-			return image.Config{}, 0, false, ErrUnsupported
-		}
-		return image.Config{ColorModel: color.RGBAModel, Width: width, Height: height}, 24, topDown, nil
-	case 32:
-		if offset != fileHeaderLen+infoHeaderLen {
-			return image.Config{}, 0, false, ErrUnsupported
-		}
-		return image.Config{ColorModel: color.RGBAModel, Width: width, Height: height}, 32, topDown, nil
-	}
-	return image.Config{}, 0, false, ErrUnsupported
-}
-
-func init() {
-	image.RegisterFormat("bmp", "BM????\x00\x00\x00\x00", Decode, DecodeConfig)
-}

vendor/golang.org/x/image/bmp/reader_test.go

@@ -1,75 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bmp
-
-import (
-	"fmt"
-	"image"
-	"os"
-	"testing"
-
-	_ "image/png"
-)
-
-const testdataDir = "../testdata/"
-
-func compare(t *testing.T, img0, img1 image.Image) error {
-	b := img1.Bounds()
-	if !b.Eq(img0.Bounds()) {
-		return fmt.Errorf("wrong image size: want %s, got %s", img0.Bounds(), b)
-	}
-	for y := b.Min.Y; y < b.Max.Y; y++ {
-		for x := b.Min.X; x < b.Max.X; x++ {
-			c0 := img0.At(x, y)
-			c1 := img1.At(x, y)
-			r0, g0, b0, a0 := c0.RGBA()
-			r1, g1, b1, a1 := c1.RGBA()
-			if r0 != r1 || g0 != g1 || b0 != b1 || a0 != a1 {
-				return fmt.Errorf("pixel at (%d, %d) has wrong color: want %v, got %v", x, y, c0, c1)
-			}
-		}
-	}
-	return nil
-}
-
-// TestDecode tests that decoding a PNG image and a BMP image result in the
-// same pixel data.
-func TestDecode(t *testing.T) {
-	testCases := []string{
-		"video-001",
-		"yellow_rose-small",
-	}
-
-	for _, tc := range testCases {
-		f0, err := os.Open(testdataDir + tc + ".png")
-		if err != nil {
-			t.Errorf("%s: Open PNG: %v", tc, err)
-			continue
-		}
-		defer f0.Close()
-		img0, _, err := image.Decode(f0)
-		if err != nil {
-			t.Errorf("%s: Decode PNG: %v", tc, err)
-			continue
-		}
-
-		f1, err := os.Open(testdataDir + tc + ".bmp")
-		if err != nil {
-			t.Errorf("%s: Open BMP: %v", tc, err)
-			continue
-		}
-		defer f1.Close()
-		img1, _, err := image.Decode(f1)
-		if err != nil {
-			t.Errorf("%s: Decode BMP: %v", tc, err)
-			continue
-		}
-
-		if err := compare(t, img0, img1); err != nil {
-			t.Errorf("%s: %v", tc, err)
-			continue
-		}
-	}
-}

vendor/golang.org/x/image/bmp/writer.go

@@ -1,166 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bmp
-
-import (
-	"encoding/binary"
-	"errors"
-	"image"
-	"io"
-)
-
-type header struct {
-	sigBM           [2]byte
-	fileSize        uint32
-	resverved       [2]uint16
-	pixOffset       uint32
-	dibHeaderSize   uint32
-	width           uint32
-	height          uint32
-	colorPlane      uint16
-	bpp             uint16
-	compression     uint32
-	imageSize       uint32
-	xPixelsPerMeter uint32
-	yPixelsPerMeter uint32
-	colorUse        uint32
-	colorImportant  uint32
-}
-
-func encodePaletted(w io.Writer, pix []uint8, dx, dy, stride, step int) error {
-	var padding []byte
-	if dx < step {
-		padding = make([]byte, step-dx)
-	}
-	for y := dy - 1; y >= 0; y-- {
-		min := y*stride + 0
-		max := y*stride + dx
-		if _, err := w.Write(pix[min:max]); err != nil {
-			return err
-		}
-		if padding != nil {
-			if _, err := w.Write(padding); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func encodeRGBA(w io.Writer, pix []uint8, dx, dy, stride, step int) error {
-	buf := make([]byte, step)
-	for y := dy - 1; y >= 0; y-- {
-		min := y*stride + 0
-		max := y*stride + dx*4
-		off := 0
-		for i := min; i < max; i += 4 {
-			buf[off+2] = pix[i+0]
-			buf[off+1] = pix[i+1]
-			buf[off+0] = pix[i+2]
-			off += 3
-		}
-		if _, err := w.Write(buf); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func encode(w io.Writer, m image.Image, step int) error {
-	b := m.Bounds()
-	buf := make([]byte, step)
-	for y := b.Max.Y - 1; y >= b.Min.Y; y-- {
-		off := 0
-		for x := b.Min.X; x < b.Max.X; x++ {
-			r, g, b, _ := m.At(x, y).RGBA()
-			buf[off+2] = byte(r >> 8)
-			buf[off+1] = byte(g >> 8)
-			buf[off+0] = byte(b >> 8)
-			off += 3
-		}
-		if _, err := w.Write(buf); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// Encode writes the image m to w in BMP format.
-func Encode(w io.Writer, m image.Image) error {
-	d := m.Bounds().Size()
-	if d.X < 0 || d.Y < 0 {
-		return errors.New("bmp: negative bounds")
-	}
-	h := &header{
-		sigBM:         [2]byte{'B', 'M'},
-		fileSize:      14 + 40,
-		pixOffset:     14 + 40,
-		dibHeaderSize: 40,
-		width:         uint32(d.X),
-		height:        uint32(d.Y),
-		colorPlane:    1,
-	}
-
-	var step int
-	var palette []byte
-	switch m := m.(type) {
-	case *image.Gray:
-		step = (d.X + 3) &^ 3
-		palette = make([]byte, 1024)
-		for i := 0; i < 256; i++ {
-			palette[i*4+0] = uint8(i)
-			palette[i*4+1] = uint8(i)
-			palette[i*4+2] = uint8(i)
-			palette[i*4+3] = 0xFF
-		}
-		h.imageSize = uint32(d.Y * step)
-		h.fileSize += uint32(len(palette)) + h.imageSize
-		h.pixOffset += uint32(len(palette))
-		h.bpp = 8
-
-	case *image.Paletted:
-		step = (d.X + 3) &^ 3
-		palette = make([]byte, 1024)
-		for i := 0; i < len(m.Palette) && i < 256; i++ {
-			r, g, b, _ := m.Palette[i].RGBA()
-			palette[i*4+0] = uint8(b >> 8)
-			palette[i*4+1] = uint8(g >> 8)
-			palette[i*4+2] = uint8(r >> 8)
-			palette[i*4+3] = 0xFF
-		}
-		h.imageSize = uint32(d.Y * step)
-		h.fileSize += uint32(len(palette)) + h.imageSize
-		h.pixOffset += uint32(len(palette))
-		h.bpp = 8
-	default:
-		step = (3*d.X + 3) &^ 3
-		h.imageSize = uint32(d.Y * step)
-		h.fileSize += h.imageSize
-		h.bpp = 24
-	}
-
-	if err := binary.Write(w, binary.LittleEndian, h); err != nil {
-		return err
-	}
-	if palette != nil {
-		if err := binary.Write(w, binary.LittleEndian, palette); err != nil {
-			return err
-		}
-	}
-
-	if d.X == 0 || d.Y == 0 {
-		return nil
-	}
-
-	switch m := m.(type) {
-	case *image.Gray:
-		return encodePaletted(w, m.Pix, d.X, d.Y, m.Stride, step)
-	case *image.Paletted:
-		return encodePaletted(w, m.Pix, d.X, d.Y, m.Stride, step)
-	case *image.RGBA:
-		return encodeRGBA(w, m.Pix, d.X, d.Y, m.Stride, step)
-	}
-	return encode(w, m, step)
-}

vendor/golang.org/x/image/bmp/writer_test.go

@@ -1,91 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package bmp
-
-import (
-	"bytes"
-	"fmt"
-	"image"
-	"io/ioutil"
-	"os"
-	"testing"
-	"time"
-)
-
-func openImage(filename string) (image.Image, error) {
-	f, err := os.Open(testdataDir + filename)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-	return Decode(f)
-}
-
-func TestEncode(t *testing.T) {
-	img0, err := openImage("video-001.bmp")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	buf := new(bytes.Buffer)
-	err = Encode(buf, img0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	img1, err := Decode(buf)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	compare(t, img0, img1)
-}
-
-// TestZeroWidthVeryLargeHeight tests that encoding and decoding a degenerate
-// image with zero width but over one billion pixels in height is faster than
-// naively calling an io.Reader or io.Writer method once per row.
-func TestZeroWidthVeryLargeHeight(t *testing.T) {
-	c := make(chan error, 1)
-	go func() {
-		b := image.Rect(0, 0, 0, 0x3fffffff)
-		var buf bytes.Buffer
-		if err := Encode(&buf, image.NewRGBA(b)); err != nil {
-			c <- err
-			return
-		}
-		m, err := Decode(&buf)
-		if err != nil {
-			c <- err
-			return
-		}
-		if got := m.Bounds(); got != b {
-			c <- fmt.Errorf("bounds: got %v, want %v", got, b)
-			return
-		}
-		c <- nil
-	}()
-	select {
-	case err := <-c:
-		if err != nil {
-			t.Fatal(err)
-		}
-	case <-time.After(3 * time.Second):
-		t.Fatalf("timed out")
-	}
-}
-
-// BenchmarkEncode benchmarks the encoding of an image.
-func BenchmarkEncode(b *testing.B) {
-	img, err := openImage("video-001.bmp")
-	if err != nil {
-		b.Fatal(err)
-	}
-	s := img.Bounds().Size()
-	b.SetBytes(int64(s.X * s.Y * 4))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		Encode(ioutil.Discard, img)
-	}
-}

vendor/golang.org/x/image/cmd/webp-manual-test/main.go

@@ -1,215 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-//
-// This build tag means that "go install golang.org/x/image/..." doesn't
-// install this manual test. Use "go run main.go" to explicitly run it.
-
-// Program webp-manual-test checks that the Go WEBP library's decodings match
-// the C WEBP library's.
-package main // import "golang.org/x/image/cmd/webp-manual-test"
-
-import (
-	"bytes"
-	"encoding/hex"
-	"flag"
-	"fmt"
-	"image"
-	"io"
-	"log"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"sort"
-	"strings"
-
-	"golang.org/x/image/webp"
-)
-
-var (
-	dwebp = flag.String("dwebp", "/usr/bin/dwebp", "path to the dwebp program "+
-		"installed from https://developers.google.com/speed/webp/download")
-	testdata = flag.String("testdata", "", "path to the libwebp-test-data directory "+
-		"checked out from https://chromium.googlesource.com/webm/libwebp-test-data")
-)
-
-func main() {
-	flag.Parse()
-	if err := checkDwebp(); err != nil {
-		flag.Usage()
-		log.Fatal(err)
-	}
-	if *testdata == "" {
-		flag.Usage()
-		log.Fatal("testdata flag was not specified")
-	}
-
-	f, err := os.Open(*testdata)
-	if err != nil {
-		log.Fatalf("Open: %v", err)
-	}
-	defer f.Close()
-	names, err := f.Readdirnames(-1)
-	if err != nil {
-		log.Fatalf("Readdirnames: %v", err)
-	}
-	sort.Strings(names)
-
-	nFail, nPass := 0, 0
-	for _, name := range names {
-		if !strings.HasSuffix(name, "webp") {
-			continue
-		}
-		if err := test(name); err != nil {
-			fmt.Printf("FAIL\t%s\t%v\n", name, err)
-			nFail++
-		} else {
-			fmt.Printf("PASS\t%s\n", name)
-			nPass++
-		}
-	}
-	fmt.Printf("%d PASS, %d FAIL, %d TOTAL\n", nPass, nFail, nPass+nFail)
-	if nFail != 0 {
-		os.Exit(1)
-	}
-}
-
-func checkDwebp() error {
-	if *dwebp == "" {
-		return fmt.Errorf("dwebp flag was not specified")
-	}
-	if _, err := os.Stat(*dwebp); err != nil {
-		return fmt.Errorf("could not find dwebp program at %q", *dwebp)
-	}
-	b, err := exec.Command(*dwebp, "-version").Output()
-	if err != nil {
-		return fmt.Errorf("could not determine the dwebp program version for %q: %v", *dwebp, err)
-	}
-	switch s := string(bytes.TrimSpace(b)); s {
-	case "0.4.0", "0.4.1", "0.4.2":
-		return fmt.Errorf("the dwebp program version %q for %q has a known bug "+
-			"(https://bugs.chromium.org/p/webp/issues/detail?id=239). Please use a newer version.", s, *dwebp)
-	}
-	return nil
-}
-
-// test tests a single WEBP image.
-func test(name string) error {
-	filename := filepath.Join(*testdata, name)
-	f, err := os.Open(filename)
-	if err != nil {
-		return fmt.Errorf("Open: %v", err)
-	}
-	defer f.Close()
-
-	gotImage, err := webp.Decode(f)
-	if err != nil {
-		return fmt.Errorf("Decode: %v", err)
-	}
-	format, encode := "-pgm", encodePGM
-	if _, lossless := gotImage.(*image.NRGBA); lossless {
-		format, encode = "-pam", encodePAM
-	}
-	got, err := encode(gotImage)
-	if err != nil {
-		return fmt.Errorf("encode: %v", err)
-	}
-
-	stdout := new(bytes.Buffer)
-	stderr := new(bytes.Buffer)
-	c := exec.Command(*dwebp, filename, format, "-o", "/dev/stdout")
-	c.Stdout = stdout
-	c.Stderr = stderr
-	if err := c.Run(); err != nil {
-		os.Stderr.Write(stderr.Bytes())
-		return fmt.Errorf("executing dwebp: %v", err)
-	}
-	want := stdout.Bytes()
-
-	if len(got) != len(want) {
-		return fmt.Errorf("encodings have different length: got %d, want %d", len(got), len(want))
-	}
-	for i, g := range got {
-		if w := want[i]; g != w {
-			return fmt.Errorf("encodings differ at position 0x%x: got 0x%02x, want 0x%02x", i, g, w)
-		}
-	}
-	return nil
-}
-
-// encodePAM encodes gotImage in the PAM format.
-func encodePAM(gotImage image.Image) ([]byte, error) {
-	m, ok := gotImage.(*image.NRGBA)
-	if !ok {
-		return nil, fmt.Errorf("lossless image did not decode to an *image.NRGBA")
-	}
-	b := m.Bounds()
-	w, h := b.Dx(), b.Dy()
-	buf := new(bytes.Buffer)
-	fmt.Fprintf(buf, "P7\nWIDTH %d\nHEIGHT %d\nDEPTH 4\nMAXVAL 255\nTUPLTYPE RGB_ALPHA\nENDHDR\n", w, h)
-	for y := b.Min.Y; y < b.Max.Y; y++ {
-		o := m.PixOffset(b.Min.X, y)
-		buf.Write(m.Pix[o : o+4*w])
-	}
-	return buf.Bytes(), nil
-}
-
-// encodePGM encodes gotImage in the PGM format in the IMC4 layout.
-func encodePGM(gotImage image.Image) ([]byte, error) {
-	var (
-		m  *image.YCbCr
-		ma *image.NYCbCrA
-	)
-	switch g := gotImage.(type) {
-	case *image.YCbCr:
-		m = g
-	case *image.NYCbCrA:
-		m = &g.YCbCr
-		ma = g
-	default:
-		return nil, fmt.Errorf("lossy image did not decode to an *image.YCbCr")
-	}
-	if m.SubsampleRatio != image.YCbCrSubsampleRatio420 {
-		return nil, fmt.Errorf("lossy image did not decode to a 4:2:0 YCbCr")
-	}
-	b := m.Bounds()
-	w, h := b.Dx(), b.Dy()
-	w2, h2 := (w+1)/2, (h+1)/2
-	outW, outH := 2*w2, h+h2
-	if ma != nil {
-		outH += h
-	}
-	buf := new(bytes.Buffer)
-	fmt.Fprintf(buf, "P5\n%d %d\n255\n", outW, outH)
-	for y := b.Min.Y; y < b.Max.Y; y++ {
-		o := m.YOffset(b.Min.X, y)
-		buf.Write(m.Y[o : o+w])
-		if w&1 != 0 {
-			buf.WriteByte(0x00)
-		}
-	}
-	for y := b.Min.Y; y < b.Max.Y; y += 2 {
-		o := m.COffset(b.Min.X, y)
-		buf.Write(m.Cb[o : o+w2])
-		buf.Write(m.Cr[o : o+w2])
-	}
-	if ma != nil {
-		for y := b.Min.Y; y < b.Max.Y; y++ {
-			o := ma.AOffset(b.Min.X, y)
-			buf.Write(ma.A[o : o+w])
-			if w&1 != 0 {
-				buf.WriteByte(0x00)
-			}
-		}
-	}
-	return buf.Bytes(), nil
-}
-
-// dump can be useful for debugging.
-func dump(w io.Writer, b []byte) {
-	h := hex.Dumper(w)
-	h.Write(b)
-	h.Close()
-}

vendor/golang.org/x/image/codereview.cfg

@@ -1 +0,0 @@
-issuerepo: golang/go

vendor/golang.org/x/image/colornames/colornames.go

@@ -1,10 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:generate go run gen.go
-
-// Package colornames provides named colors as defined in the SVG 1.1 spec.
-//
-// See http://www.w3.org/TR/SVG/types.html#ColorKeywords
-package colornames

vendor/golang.org/x/image/colornames/colornames_test.go

@@ -1,42 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package colornames
-
-import (
-	"image/color"
-	"testing"
-)
-
-func TestColornames(t *testing.T) {
-	if len(Map) != len(Names) {
-		t.Fatalf("Map and Names have different length: %d vs %d", len(Map), len(Names))
-	}
-
-	for name, want := range testCases {
-		got, ok := Map[name]
-		if !ok {
-			t.Errorf("Did not find %s", name)
-			continue
-		}
-		if got != want {
-			t.Errorf("%s:\ngot  %v\nwant %v", name, got, want)
-		}
-	}
-}
-
-var testCases = map[string]color.RGBA{
-	"aliceblue":      color.RGBA{240, 248, 255, 255},
-	"crimson":        color.RGBA{220, 20, 60, 255},
-	"darkorange":     color.RGBA{255, 140, 0, 255},
-	"deepskyblue":    color.RGBA{0, 191, 255, 255},
-	"greenyellow":    color.RGBA{173, 255, 47, 255},
-	"lightgrey":      color.RGBA{211, 211, 211, 255},
-	"lightpink":      color.RGBA{255, 182, 193, 255},
-	"mediumseagreen": color.RGBA{60, 179, 113, 255},
-	"olivedrab":      color.RGBA{107, 142, 35, 255},
-	"purple":         color.RGBA{128, 0, 128, 255},
-	"slategrey":      color.RGBA{112, 128, 144, 255},
-	"yellowgreen":    color.RGBA{154, 205, 50, 255},
-}

vendor/golang.org/x/image/colornames/gen.go

@@ -1,197 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// This program generates table.go from
-// http://www.w3.org/TR/SVG/types.html#ColorKeywords
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"go/format"
-	"image/color"
-	"io"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-
-	"golang.org/x/net/html"
-	"golang.org/x/net/html/atom"
-)
-
-// matchFunc matches HTML nodes.
-type matchFunc func(*html.Node) bool
-
-// appendAll recursively traverses the parse tree rooted under the provided
-// node and appends all nodes matched by the matchFunc to dst.
-func appendAll(dst []*html.Node, n *html.Node, mf matchFunc) []*html.Node {
-	if mf(n) {
-		dst = append(dst, n)
-	}
-	for c := n.FirstChild; c != nil; c = c.NextSibling {
-		dst = appendAll(dst, c, mf)
-	}
-	return dst
-}
-
-// matchAtom returns a matchFunc that matches a Node with the specified Atom.
-func matchAtom(a atom.Atom) matchFunc {
-	return func(n *html.Node) bool {
-		return n.DataAtom == a
-	}
-}
-
-// matchAtomAttr returns a matchFunc that matches a Node with the specified
-// Atom and a html.Attribute's namespace, key and value.
-func matchAtomAttr(a atom.Atom, namespace, key, value string) matchFunc {
-	return func(n *html.Node) bool {
-		return n.DataAtom == a && getAttr(n, namespace, key) == value
-	}
-}
-
-// getAttr fetches the value of a html.Attribute for a given namespace and key.
-func getAttr(n *html.Node, namespace, key string) string {
-	for _, attr := range n.Attr {
-		if attr.Namespace == namespace && attr.Key == key {
-			return attr.Val
-		}
-	}
-	return ""
-}
-
-// re extracts RGB values from strings like "rgb( 0, 223, 128)".
-var re = regexp.MustCompile(`rgb\(\s*([0-9]+),\s*([0-9]+),\s*([0-9]+)\)`)
-
-// parseRGB parses a color from a string like "rgb( 0, 233, 128)". It sets
-// the alpha value of the color to full opacity.
-func parseRGB(s string) (color.RGBA, error) {
-	m := re.FindStringSubmatch(s)
-	if m == nil {
-		return color.RGBA{}, fmt.Errorf("malformed color: %q", s)
-	}
-	var rgb [3]uint8
-	for i, t := range m[1:] {
-		num, err := strconv.ParseUint(t, 10, 8)
-		if err != nil {
-			return color.RGBA{}, fmt.Errorf("malformed value %q in %q: %s", t, s, err)
-		}
-		rgb[i] = uint8(num)
-	}
-	return color.RGBA{rgb[0], rgb[1], rgb[2], 0xFF}, nil
-}
-
-// extractSVGColors extracts named colors from the parse tree of the SVG 1.1
-// spec HTML document "Chapter 4: Basic data types and interfaces".
-func extractSVGColors(tree *html.Node) (map[string]color.RGBA, error) {
-	ret := make(map[string]color.RGBA)
-
-	// Find the tables which store the color keywords in the parse tree.
-	colorTables := appendAll(nil, tree, func(n *html.Node) bool {
-		return n.DataAtom == atom.Table && strings.Contains(getAttr(n, "", "summary"), "color keywords part")
-	})
-
-	for _, table := range colorTables {
-		// Color names and values are stored in TextNodes within spans in each row.
-		for _, tr := range appendAll(nil, table, matchAtom(atom.Tr)) {
-			nameSpan := appendAll(nil, tr, matchAtomAttr(atom.Span, "", "class", "prop-value"))
-			valueSpan := appendAll(nil, tr, matchAtomAttr(atom.Span, "", "class", "color-keyword-value"))
-
-			// Since SVG 1.1 defines an odd number of colors, the last row
-			// in the second table does not have contents. We skip it.
-			if len(nameSpan) != 1 || len(valueSpan) != 1 {
-				continue
-			}
-			n, v := nameSpan[0].FirstChild, valueSpan[0].FirstChild
-			// This sanity checks for the existence of TextNodes under spans.
-			if n == nil || n.Type != html.TextNode || v == nil || v.Type != html.TextNode {
-				return nil, fmt.Errorf("extractSVGColors: couldn't find name/value text nodes")
-			}
-			val, err := parseRGB(v.Data)
-			if err != nil {
-				return nil, fmt.Errorf("extractSVGColors: couldn't parse name/value %q/%q: %s", n.Data, v.Data, err)
-			}
-			ret[n.Data] = val
-		}
-	}
-	return ret, nil
-}
-
-const preamble = `// generated by go generate; DO NOT EDIT.
-
-package colornames
-
-import "image/color"
-
-`
-
-// WriteColorNames writes table.go.
-func writeColorNames(w io.Writer, m map[string]color.RGBA) {
-	keys := make([]string, 0, len(m))
-	for k := range m {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-
-	fmt.Fprintln(w, preamble)
-	fmt.Fprintln(w, "// Map contains named colors defined in the SVG 1.1 spec.")
-	fmt.Fprintln(w, "var Map = map[string]color.RGBA{")
-	for _, k := range keys {
-		c := m[k]
-		fmt.Fprintf(w, "%q:color.RGBA{%#02x, %#02x, %#02x, %#02x}, // rgb(%d, %d, %d)\n",
-			k, c.R, c.G, c.B, c.A, c.R, c.G, c.B)
-	}
-	fmt.Fprintln(w, "}\n")
-	fmt.Fprintln(w, "// Names contains the color names defined in the SVG 1.1 spec.")
-	fmt.Fprintln(w, "var Names = []string{")
-	for _, k := range keys {
-		fmt.Fprintf(w, "%q,\n", k)
-	}
-	fmt.Fprintln(w, "}\n")
-	fmt.Fprintln(w, "var (")
-	for _, k := range keys {
-		c := m[k]
-		// Make the upper case version of k: "Darkred" instead of "darkred".
-		k = string(k[0]-0x20) + k[1:]
-		fmt.Fprintf(w, "%s=color.RGBA{%#02x, %#02x, %#02x, %#02x} // rgb(%d, %d, %d)\n",
-			k, c.R, c.G, c.B, c.A, c.R, c.G, c.B)
-	}
-	fmt.Fprintln(w, ")")
-}
-
-const url = "http://www.w3.org/TR/SVG/types.html"
-
-func main() {
-	res, err := http.Get(url)
-	if err != nil {
-		log.Fatalf("Couldn't read from %s: %s\n", url, err)
-	}
-	defer res.Body.Close()
-
-	tree, err := html.Parse(res.Body)
-	if err != nil {
-		log.Fatalf("Couldn't parse %s: %s\n", url, err)
-	}
-
-	colors, err := extractSVGColors(tree)
-	if err != nil {
-		log.Fatalf("Couldn't extract colors: %s\n", err)
-	}
-
-	buf := &bytes.Buffer{}
-	writeColorNames(buf, colors)
-	fmted, err := format.Source(buf.Bytes())
-	if err != nil {
-		log.Fatalf("Error while formatting code: %s\n", err)
-	}
-
-	if err := ioutil.WriteFile("table.go", fmted, 0644); err != nil {
-		log.Fatalf("Error writing table.go: %s\n", err)
-	}
-}

vendor/golang.org/x/image/colornames/table.go

@@ -1,457 +0,0 @@
-// generated by go generate; DO NOT EDIT.
-
-package colornames
-
-import "image/color"
-
-// Map contains named colors defined in the SVG 1.1 spec.
-var Map = map[string]color.RGBA{
-	"aliceblue":            color.RGBA{0xf0, 0xf8, 0xff, 0xff}, // rgb(240, 248, 255)
-	"antiquewhite":         color.RGBA{0xfa, 0xeb, 0xd7, 0xff}, // rgb(250, 235, 215)
-	"aqua":                 color.RGBA{0x00, 0xff, 0xff, 0xff}, // rgb(0, 255, 255)
-	"aquamarine":           color.RGBA{0x7f, 0xff, 0xd4, 0xff}, // rgb(127, 255, 212)
-	"azure":                color.RGBA{0xf0, 0xff, 0xff, 0xff}, // rgb(240, 255, 255)
-	"beige":                color.RGBA{0xf5, 0xf5, 0xdc, 0xff}, // rgb(245, 245, 220)
-	"bisque":               color.RGBA{0xff, 0xe4, 0xc4, 0xff}, // rgb(255, 228, 196)
-	"black":                color.RGBA{0x00, 0x00, 0x00, 0xff}, // rgb(0, 0, 0)
-	"blanchedalmond":       color.RGBA{0xff, 0xeb, 0xcd, 0xff}, // rgb(255, 235, 205)
-	"blue":                 color.RGBA{0x00, 0x00, 0xff, 0xff}, // rgb(0, 0, 255)
-	"blueviolet":           color.RGBA{0x8a, 0x2b, 0xe2, 0xff}, // rgb(138, 43, 226)
-	"brown":                color.RGBA{0xa5, 0x2a, 0x2a, 0xff}, // rgb(165, 42, 42)
-	"burlywood":            color.RGBA{0xde, 0xb8, 0x87, 0xff}, // rgb(222, 184, 135)
-	"cadetblue":            color.RGBA{0x5f, 0x9e, 0xa0, 0xff}, // rgb(95, 158, 160)
-	"chartreuse":           color.RGBA{0x7f, 0xff, 0x00, 0xff}, // rgb(127, 255, 0)
-	"chocolate":            color.RGBA{0xd2, 0x69, 0x1e, 0xff}, // rgb(210, 105, 30)
-	"coral":                color.RGBA{0xff, 0x7f, 0x50, 0xff}, // rgb(255, 127, 80)
-	"cornflowerblue":       color.RGBA{0x64, 0x95, 0xed, 0xff}, // rgb(100, 149, 237)
-	"cornsilk":             color.RGBA{0xff, 0xf8, 0xdc, 0xff}, // rgb(255, 248, 220)
-	"crimson":              color.RGBA{0xdc, 0x14, 0x3c, 0xff}, // rgb(220, 20, 60)
-	"cyan":                 color.RGBA{0x00, 0xff, 0xff, 0xff}, // rgb(0, 255, 255)
-	"darkblue":             color.RGBA{0x00, 0x00, 0x8b, 0xff}, // rgb(0, 0, 139)
-	"darkcyan":             color.RGBA{0x00, 0x8b, 0x8b, 0xff}, // rgb(0, 139, 139)
-	"darkgoldenrod":        color.RGBA{0xb8, 0x86, 0x0b, 0xff}, // rgb(184, 134, 11)
-	"darkgray":             color.RGBA{0xa9, 0xa9, 0xa9, 0xff}, // rgb(169, 169, 169)
-	"darkgreen":            color.RGBA{0x00, 0x64, 0x00, 0xff}, // rgb(0, 100, 0)
-	"darkgrey":             color.RGBA{0xa9, 0xa9, 0xa9, 0xff}, // rgb(169, 169, 169)
-	"darkkhaki":            color.RGBA{0xbd, 0xb7, 0x6b, 0xff}, // rgb(189, 183, 107)
-	"darkmagenta":          color.RGBA{0x8b, 0x00, 0x8b, 0xff}, // rgb(139, 0, 139)
-	"darkolivegreen":       color.RGBA{0x55, 0x6b, 0x2f, 0xff}, // rgb(85, 107, 47)
-	"darkorange":           color.RGBA{0xff, 0x8c, 0x00, 0xff}, // rgb(255, 140, 0)
-	"darkorchid":           color.RGBA{0x99, 0x32, 0xcc, 0xff}, // rgb(153, 50, 204)
-	"darkred":              color.RGBA{0x8b, 0x00, 0x00, 0xff}, // rgb(139, 0, 0)
-	"darksalmon":           color.RGBA{0xe9, 0x96, 0x7a, 0xff}, // rgb(233, 150, 122)
-	"darkseagreen":         color.RGBA{0x8f, 0xbc, 0x8f, 0xff}, // rgb(143, 188, 143)
-	"darkslateblue":        color.RGBA{0x48, 0x3d, 0x8b, 0xff}, // rgb(72, 61, 139)
-	"darkslategray":        color.RGBA{0x2f, 0x4f, 0x4f, 0xff}, // rgb(47, 79, 79)
-	"darkslategrey":        color.RGBA{0x2f, 0x4f, 0x4f, 0xff}, // rgb(47, 79, 79)
-	"darkturquoise":        color.RGBA{0x00, 0xce, 0xd1, 0xff}, // rgb(0, 206, 209)
-	"darkviolet":           color.RGBA{0x94, 0x00, 0xd3, 0xff}, // rgb(148, 0, 211)
-	"deeppink":             color.RGBA{0xff, 0x14, 0x93, 0xff}, // rgb(255, 20, 147)
-	"deepskyblue":          color.RGBA{0x00, 0xbf, 0xff, 0xff}, // rgb(0, 191, 255)
-	"dimgray":              color.RGBA{0x69, 0x69, 0x69, 0xff}, // rgb(105, 105, 105)
-	"dimgrey":              color.RGBA{0x69, 0x69, 0x69, 0xff}, // rgb(105, 105, 105)
-	"dodgerblue":           color.RGBA{0x1e, 0x90, 0xff, 0xff}, // rgb(30, 144, 255)
-	"firebrick":            color.RGBA{0xb2, 0x22, 0x22, 0xff}, // rgb(178, 34, 34)
-	"floralwhite":          color.RGBA{0xff, 0xfa, 0xf0, 0xff}, // rgb(255, 250, 240)
-	"forestgreen":          color.RGBA{0x22, 0x8b, 0x22, 0xff}, // rgb(34, 139, 34)
-	"fuchsia":              color.RGBA{0xff, 0x00, 0xff, 0xff}, // rgb(255, 0, 255)
-	"gainsboro":            color.RGBA{0xdc, 0xdc, 0xdc, 0xff}, // rgb(220, 220, 220)
-	"ghostwhite":           color.RGBA{0xf8, 0xf8, 0xff, 0xff}, // rgb(248, 248, 255)
-	"gold":                 color.RGBA{0xff, 0xd7, 0x00, 0xff}, // rgb(255, 215, 0)
-	"goldenrod":            color.RGBA{0xda, 0xa5, 0x20, 0xff}, // rgb(218, 165, 32)
-	"gray":                 color.RGBA{0x80, 0x80, 0x80, 0xff}, // rgb(128, 128, 128)
-	"green":                color.RGBA{0x00, 0x80, 0x00, 0xff}, // rgb(0, 128, 0)
-	"greenyellow":          color.RGBA{0xad, 0xff, 0x2f, 0xff}, // rgb(173, 255, 47)
-	"grey":                 color.RGBA{0x80, 0x80, 0x80, 0xff}, // rgb(128, 128, 128)
-	"honeydew":             color.RGBA{0xf0, 0xff, 0xf0, 0xff}, // rgb(240, 255, 240)
-	"hotpink":              color.RGBA{0xff, 0x69, 0xb4, 0xff}, // rgb(255, 105, 180)
-	"indianred":            color.RGBA{0xcd, 0x5c, 0x5c, 0xff}, // rgb(205, 92, 92)
-	"indigo":               color.RGBA{0x4b, 0x00, 0x82, 0xff}, // rgb(75, 0, 130)
-	"ivory":                color.RGBA{0xff, 0xff, 0xf0, 0xff}, // rgb(255, 255, 240)
-	"khaki":                color.RGBA{0xf0, 0xe6, 0x8c, 0xff}, // rgb(240, 230, 140)
-	"lavender":             color.RGBA{0xe6, 0xe6, 0xfa, 0xff}, // rgb(230, 230, 250)
-	"lavenderblush":        color.RGBA{0xff, 0xf0, 0xf5, 0xff}, // rgb(255, 240, 245)
-	"lawngreen":            color.RGBA{0x7c, 0xfc, 0x00, 0xff}, // rgb(124, 252, 0)
-	"lemonchiffon":         color.RGBA{0xff, 0xfa, 0xcd, 0xff}, // rgb(255, 250, 205)
-	"lightblue":            color.RGBA{0xad, 0xd8, 0xe6, 0xff}, // rgb(173, 216, 230)
-	"lightcoral":           color.RGBA{0xf0, 0x80, 0x80, 0xff}, // rgb(240, 128, 128)
-	"lightcyan":            color.RGBA{0xe0, 0xff, 0xff, 0xff}, // rgb(224, 255, 255)
-	"lightgoldenrodyellow": color.RGBA{0xfa, 0xfa, 0xd2, 0xff}, // rgb(250, 250, 210)
-	"lightgray":            color.RGBA{0xd3, 0xd3, 0xd3, 0xff}, // rgb(211, 211, 211)
-	"lightgreen":           color.RGBA{0x90, 0xee, 0x90, 0xff}, // rgb(144, 238, 144)
-	"lightgrey":            color.RGBA{0xd3, 0xd3, 0xd3, 0xff}, // rgb(211, 211, 211)
-	"lightpink":            color.RGBA{0xff, 0xb6, 0xc1, 0xff}, // rgb(255, 182, 193)
-	"lightsalmon":          color.RGBA{0xff, 0xa0, 0x7a, 0xff}, // rgb(255, 160, 122)
-	"lightseagreen":        color.RGBA{0x20, 0xb2, 0xaa, 0xff}, // rgb(32, 178, 170)
-	"lightskyblue":         color.RGBA{0x87, 0xce, 0xfa, 0xff}, // rgb(135, 206, 250)
-	"lightslategray":       color.RGBA{0x77, 0x88, 0x99, 0xff}, // rgb(119, 136, 153)
-	"lightslategrey":       color.RGBA{0x77, 0x88, 0x99, 0xff}, // rgb(119, 136, 153)
-	"lightsteelblue":       color.RGBA{0xb0, 0xc4, 0xde, 0xff}, // rgb(176, 196, 222)
-	"lightyellow":          color.RGBA{0xff, 0xff, 0xe0, 0xff}, // rgb(255, 255, 224)
-	"lime":                 color.RGBA{0x00, 0xff, 0x00, 0xff}, // rgb(0, 255, 0)
-	"limegreen":            color.RGBA{0x32, 0xcd, 0x32, 0xff}, // rgb(50, 205, 50)
-	"linen":                color.RGBA{0xfa, 0xf0, 0xe6, 0xff}, // rgb(250, 240, 230)
-	"magenta":              color.RGBA{0xff, 0x00, 0xff, 0xff}, // rgb(255, 0, 255)
-	"maroon":               color.RGBA{0x80, 0x00, 0x00, 0xff}, // rgb(128, 0, 0)
-	"mediumaquamarine":     color.RGBA{0x66, 0xcd, 0xaa, 0xff}, // rgb(102, 205, 170)
-	"mediumblue":           color.RGBA{0x00, 0x00, 0xcd, 0xff}, // rgb(0, 0, 205)
-	"mediumorchid":         color.RGBA{0xba, 0x55, 0xd3, 0xff}, // rgb(186, 85, 211)
-	"mediumpurple":         color.RGBA{0x93, 0x70, 0xdb, 0xff}, // rgb(147, 112, 219)
-	"mediumseagreen":       color.RGBA{0x3c, 0xb3, 0x71, 0xff}, // rgb(60, 179, 113)
-	"mediumslateblue":      color.RGBA{0x7b, 0x68, 0xee, 0xff}, // rgb(123, 104, 238)
-	"mediumspringgreen":    color.RGBA{0x00, 0xfa, 0x9a, 0xff}, // rgb(0, 250, 154)
-	"mediumturquoise":      color.RGBA{0x48, 0xd1, 0xcc, 0xff}, // rgb(72, 209, 204)
-	"mediumvioletred":      color.RGBA{0xc7, 0x15, 0x85, 0xff}, // rgb(199, 21, 133)
-	"midnightblue":         color.RGBA{0x19, 0x19, 0x70, 0xff}, // rgb(25, 25, 112)
-	"mintcream":            color.RGBA{0xf5, 0xff, 0xfa, 0xff}, // rgb(245, 255, 250)
-	"mistyrose":            color.RGBA{0xff, 0xe4, 0xe1, 0xff}, // rgb(255, 228, 225)
-	"moccasin":             color.RGBA{0xff, 0xe4, 0xb5, 0xff}, // rgb(255, 228, 181)
-	"navajowhite":          color.RGBA{0xff, 0xde, 0xad, 0xff}, // rgb(255, 222, 173)
-	"navy":                 color.RGBA{0x00, 0x00, 0x80, 0xff}, // rgb(0, 0, 128)
-	"oldlace":              color.RGBA{0xfd, 0xf5, 0xe6, 0xff}, // rgb(253, 245, 230)
-	"olive":                color.RGBA{0x80, 0x80, 0x00, 0xff}, // rgb(128, 128, 0)
-	"olivedrab":            color.RGBA{0x6b, 0x8e, 0x23, 0xff}, // rgb(107, 142, 35)
-	"orange":               color.RGBA{0xff, 0xa5, 0x00, 0xff}, // rgb(255, 165, 0)
-	"orangered":            color.RGBA{0xff, 0x45, 0x00, 0xff}, // rgb(255, 69, 0)
-	"orchid":               color.RGBA{0xda, 0x70, 0xd6, 0xff}, // rgb(218, 112, 214)
-	"palegoldenrod":        color.RGBA{0xee, 0xe8, 0xaa, 0xff}, // rgb(238, 232, 170)
-	"palegreen":            color.RGBA{0x98, 0xfb, 0x98, 0xff}, // rgb(152, 251, 152)
-	"paleturquoise":        color.RGBA{0xaf, 0xee, 0xee, 0xff}, // rgb(175, 238, 238)
-	"palevioletred":        color.RGBA{0xdb, 0x70, 0x93, 0xff}, // rgb(219, 112, 147)
-	"papayawhip":           color.RGBA{0xff, 0xef, 0xd5, 0xff}, // rgb(255, 239, 213)
-	"peachpuff":            color.RGBA{0xff, 0xda, 0xb9, 0xff}, // rgb(255, 218, 185)
-	"peru":                 color.RGBA{0xcd, 0x85, 0x3f, 0xff}, // rgb(205, 133, 63)
-	"pink":                 color.RGBA{0xff, 0xc0, 0xcb, 0xff}, // rgb(255, 192, 203)
-	"plum":                 color.RGBA{0xdd, 0xa0, 0xdd, 0xff}, // rgb(221, 160, 221)
-	"powderblue":           color.RGBA{0xb0, 0xe0, 0xe6, 0xff}, // rgb(176, 224, 230)
-	"purple":               color.RGBA{0x80, 0x00, 0x80, 0xff}, // rgb(128, 0, 128)
-	"red":                  color.RGBA{0xff, 0x00, 0x00, 0xff}, // rgb(255, 0, 0)
-	"rosybrown":            color.RGBA{0xbc, 0x8f, 0x8f, 0xff}, // rgb(188, 143, 143)
-	"royalblue":            color.RGBA{0x41, 0x69, 0xe1, 0xff}, // rgb(65, 105, 225)
-	"saddlebrown":          color.RGBA{0x8b, 0x45, 0x13, 0xff}, // rgb(139, 69, 19)
-	"salmon":               color.RGBA{0xfa, 0x80, 0x72, 0xff}, // rgb(250, 128, 114)
-	"sandybrown":           color.RGBA{0xf4, 0xa4, 0x60, 0xff}, // rgb(244, 164, 96)
-	"seagreen":             color.RGBA{0x2e, 0x8b, 0x57, 0xff}, // rgb(46, 139, 87)
-	"seashell":             color.RGBA{0xff, 0xf5, 0xee, 0xff}, // rgb(255, 245, 238)
-	"sienna":               color.RGBA{0xa0, 0x52, 0x2d, 0xff}, // rgb(160, 82, 45)
-	"silver":               color.RGBA{0xc0, 0xc0, 0xc0, 0xff}, // rgb(192, 192, 192)
-	"skyblue":              color.RGBA{0x87, 0xce, 0xeb, 0xff}, // rgb(135, 206, 235)
-	"slateblue":            color.RGBA{0x6a, 0x5a, 0xcd, 0xff}, // rgb(106, 90, 205)
-	"slategray":            color.RGBA{0x70, 0x80, 0x90, 0xff}, // rgb(112, 128, 144)
-	"slategrey":            color.RGBA{0x70, 0x80, 0x90, 0xff}, // rgb(112, 128, 144)
-	"snow":                 color.RGBA{0xff, 0xfa, 0xfa, 0xff}, // rgb(255, 250, 250)
-	"springgreen":          color.RGBA{0x00, 0xff, 0x7f, 0xff}, // rgb(0, 255, 127)
-	"steelblue":            color.RGBA{0x46, 0x82, 0xb4, 0xff}, // rgb(70, 130, 180)
-	"tan":                  color.RGBA{0xd2, 0xb4, 0x8c, 0xff}, // rgb(210, 180, 140)
-	"teal":                 color.RGBA{0x00, 0x80, 0x80, 0xff}, // rgb(0, 128, 128)
-	"thistle":              color.RGBA{0xd8, 0xbf, 0xd8, 0xff}, // rgb(216, 191, 216)
-	"tomato":               color.RGBA{0xff, 0x63, 0x47, 0xff}, // rgb(255, 99, 71)
-	"turquoise":            color.RGBA{0x40, 0xe0, 0xd0, 0xff}, // rgb(64, 224, 208)
-	"violet":               color.RGBA{0xee, 0x82, 0xee, 0xff}, // rgb(238, 130, 238)
-	"wheat":                color.RGBA{0xf5, 0xde, 0xb3, 0xff}, // rgb(245, 222, 179)
-	"white":                color.RGBA{0xff, 0xff, 0xff, 0xff}, // rgb(255, 255, 255)
-	"whitesmoke":           color.RGBA{0xf5, 0xf5, 0xf5, 0xff}, // rgb(245, 245, 245)
-	"yellow":               color.RGBA{0xff, 0xff, 0x00, 0xff}, // rgb(255, 255, 0)
-	"yellowgreen":          color.RGBA{0x9a, 0xcd, 0x32, 0xff}, // rgb(154, 205, 50)
-}
-
-// Names contains the color names defined in the SVG 1.1 spec.
-var Names = []string{
-	"aliceblue",
-	"antiquewhite",
-	"aqua",
-	"aquamarine",
-	"azure",
-	"beige",
-	"bisque",
-	"black",
-	"blanchedalmond",
-	"blue",
-	"blueviolet",
-	"brown",
-	"burlywood",
-	"cadetblue",
-	"chartreuse",
-	"chocolate",
-	"coral",
-	"cornflowerblue",
-	"cornsilk",
-	"crimson",
-	"cyan",
-	"darkblue",
-	"darkcyan",
-	"darkgoldenrod",
-	"darkgray",
-	"darkgreen",
-	"darkgrey",
-	"darkkhaki",
-	"darkmagenta",
-	"darkolivegreen",
-	"darkorange",
-	"darkorchid",
-	"darkred",
-	"darksalmon",
-	"darkseagreen",
-	"darkslateblue",
-	"darkslategray",
-	"darkslategrey",
-	"darkturquoise",
-	"darkviolet",
-	"deeppink",
-	"deepskyblue",
-	"dimgray",
-	"dimgrey",
-	"dodgerblue",
-	"firebrick",
-	"floralwhite",
-	"forestgreen",
-	"fuchsia",
-	"gainsboro",
-	"ghostwhite",
-	"gold",
-	"goldenrod",
-	"gray",
-	"green",
-	"greenyellow",
-	"grey",
-	"honeydew",
-	"hotpink",
-	"indianred",
-	"indigo",
-	"ivory",
-	"khaki",
-	"lavender",
-	"lavenderblush",
-	"lawngreen",
-	"lemonchiffon",
-	"lightblue",
-	"lightcoral",
-	"lightcyan",
-	"lightgoldenrodyellow",
-	"lightgray",
-	"lightgreen",
-	"lightgrey",
-	"lightpink",
-	"lightsalmon",
-	"lightseagreen",
-	"lightskyblue",
-	"lightslategray",
-	"lightslategrey",
-	"lightsteelblue",
-	"lightyellow",
-	"lime",
-	"limegreen",
-	"linen",
-	"magenta",
-	"maroon",
-	"mediumaquamarine",
-	"mediumblue",
-	"mediumorchid",
-	"mediumpurple",
-	"mediumseagreen",
-	"mediumslateblue",
-	"mediumspringgreen",
-	"mediumturquoise",
-	"mediumvioletred",
-	"midnightblue",
-	"mintcream",
-	"mistyrose",
-	"moccasin",
-	"navajowhite",
-	"navy",
-	"oldlace",
-	"olive",
-	"olivedrab",
-	"orange",
-	"orangered",
-	"orchid",
-	"palegoldenrod",
-	"palegreen",
-	"paleturquoise",
-	"palevioletred",
-	"papayawhip",
-	"peachpuff",
-	"peru",
-	"pink",
-	"plum",
-	"powderblue",
-	"purple",
-	"red",
-	"rosybrown",
-	"royalblue",
-	"saddlebrown",
-	"salmon",
-	"sandybrown",
-	"seagreen",
-	"seashell",
-	"sienna",
-	"silver",
-	"skyblue",
-	"slateblue",
-	"slategray",
-	"slategrey",
-	"snow",
-	"springgreen",
-	"steelblue",
-	"tan",
-	"teal",
-	"thistle",
-	"tomato",
-	"turquoise",
-	"violet",
-	"wheat",
-	"white",
-	"whitesmoke",
-	"yellow",
-	"yellowgreen",
-}
-
-var (
-	Aliceblue            = color.RGBA{0xf0, 0xf8, 0xff, 0xff} // rgb(240, 248, 255)
-	Antiquewhite         = color.RGBA{0xfa, 0xeb, 0xd7, 0xff} // rgb(250, 235, 215)
-	Aqua                 = color.RGBA{0x00, 0xff, 0xff, 0xff} // rgb(0, 255, 255)
-	Aquamarine           = color.RGBA{0x7f, 0xff, 0xd4, 0xff} // rgb(127, 255, 212)
-	Azure                = color.RGBA{0xf0, 0xff, 0xff, 0xff} // rgb(240, 255, 255)
-	Beige                = color.RGBA{0xf5, 0xf5, 0xdc, 0xff} // rgb(245, 245, 220)
-	Bisque               = color.RGBA{0xff, 0xe4, 0xc4, 0xff} // rgb(255, 228, 196)
-	Black                = color.RGBA{0x00, 0x00, 0x00, 0xff} // rgb(0, 0, 0)
-	Blanchedalmond       = color.RGBA{0xff, 0xeb, 0xcd, 0xff} // rgb(255, 235, 205)
-	Blue                 = color.RGBA{0x00, 0x00, 0xff, 0xff} // rgb(0, 0, 255)
-	Blueviolet           = color.RGBA{0x8a, 0x2b, 0xe2, 0xff} // rgb(138, 43, 226)
-	Brown                = color.RGBA{0xa5, 0x2a, 0x2a, 0xff} // rgb(165, 42, 42)
-	Burlywood            = color.RGBA{0xde, 0xb8, 0x87, 0xff} // rgb(222, 184, 135)
-	Cadetblue            = color.RGBA{0x5f, 0x9e, 0xa0, 0xff} // rgb(95, 158, 160)
-	Chartreuse           = color.RGBA{0x7f, 0xff, 0x00, 0xff} // rgb(127, 255, 0)
-	Chocolate            = color.RGBA{0xd2, 0x69, 0x1e, 0xff} // rgb(210, 105, 30)
-	Coral                = color.RGBA{0xff, 0x7f, 0x50, 0xff} // rgb(255, 127, 80)
-	Cornflowerblue       = color.RGBA{0x64, 0x95, 0xed, 0xff} // rgb(100, 149, 237)
-	Cornsilk             = color.RGBA{0xff, 0xf8, 0xdc, 0xff} // rgb(255, 248, 220)
-	Crimson              = color.RGBA{0xdc, 0x14, 0x3c, 0xff} // rgb(220, 20, 60)
-	Cyan                 = color.RGBA{0x00, 0xff, 0xff, 0xff} // rgb(0, 255, 255)
-	Darkblue             = color.RGBA{0x00, 0x00, 0x8b, 0xff} // rgb(0, 0, 139)
-	Darkcyan             = color.RGBA{0x00, 0x8b, 0x8b, 0xff} // rgb(0, 139, 139)
-	Darkgoldenrod        = color.RGBA{0xb8, 0x86, 0x0b, 0xff} // rgb(184, 134, 11)
-	Darkgray             = color.RGBA{0xa9, 0xa9, 0xa9, 0xff} // rgb(169, 169, 169)
-	Darkgreen            = color.RGBA{0x00, 0x64, 0x00, 0xff} // rgb(0, 100, 0)
-	Darkgrey             = color.RGBA{0xa9, 0xa9, 0xa9, 0xff} // rgb(169, 169, 169)
-	Darkkhaki            = color.RGBA{0xbd, 0xb7, 0x6b, 0xff} // rgb(189, 183, 107)
-	Darkmagenta          = color.RGBA{0x8b, 0x00, 0x8b, 0xff} // rgb(139, 0, 139)
-	Darkolivegreen       = color.RGBA{0x55, 0x6b, 0x2f, 0xff} // rgb(85, 107, 47)
-	Darkorange           = color.RGBA{0xff, 0x8c, 0x00, 0xff} // rgb(255, 140, 0)
-	Darkorchid           = color.RGBA{0x99, 0x32, 0xcc, 0xff} // rgb(153, 50, 204)
-	Darkred              = color.RGBA{0x8b, 0x00, 0x00, 0xff} // rgb(139, 0, 0)
-	Darksalmon           = color.RGBA{0xe9, 0x96, 0x7a, 0xff} // rgb(233, 150, 122)
-	Darkseagreen         = color.RGBA{0x8f, 0xbc, 0x8f, 0xff} // rgb(143, 188, 143)
-	Darkslateblue        = color.RGBA{0x48, 0x3d, 0x8b, 0xff} // rgb(72, 61, 139)
-	Darkslategray        = color.RGBA{0x2f, 0x4f, 0x4f, 0xff} // rgb(47, 79, 79)
-	Darkslategrey        = color.RGBA{0x2f, 0x4f, 0x4f, 0xff} // rgb(47, 79, 79)
-	Darkturquoise        = color.RGBA{0x00, 0xce, 0xd1, 0xff} // rgb(0, 206, 209)
-	Darkviolet           = color.RGBA{0x94, 0x00, 0xd3, 0xff} // rgb(148, 0, 211)
-	Deeppink             = color.RGBA{0xff, 0x14, 0x93, 0xff} // rgb(255, 20, 147)
-	Deepskyblue          = color.RGBA{0x00, 0xbf, 0xff, 0xff} // rgb(0, 191, 255)
-	Dimgray              = color.RGBA{0x69, 0x69, 0x69, 0xff} // rgb(105, 105, 105)
-	Dimgrey              = color.RGBA{0x69, 0x69, 0x69, 0xff} // rgb(105, 105, 105)
-	Dodgerblue           = color.RGBA{0x1e, 0x90, 0xff, 0xff} // rgb(30, 144, 255)
-	Firebrick            = color.RGBA{0xb2, 0x22, 0x22, 0xff} // rgb(178, 34, 34)
-	Floralwhite          = color.RGBA{0xff, 0xfa, 0xf0, 0xff} // rgb(255, 250, 240)
-	Forestgreen          = color.RGBA{0x22, 0x8b, 0x22, 0xff} // rgb(34, 139, 34)
-	Fuchsia              = color.RGBA{0xff, 0x00, 0xff, 0xff} // rgb(255, 0, 255)
-	Gainsboro            = color.RGBA{0xdc, 0xdc, 0xdc, 0xff} // rgb(220, 220, 220)
-	Ghostwhite           = color.RGBA{0xf8, 0xf8, 0xff, 0xff} // rgb(248, 248, 255)
-	Gold                 = color.RGBA{0xff, 0xd7, 0x00, 0xff} // rgb(255, 215, 0)
-	Goldenrod            = color.RGBA{0xda, 0xa5, 0x20, 0xff} // rgb(218, 165, 32)
-	Gray                 = color.RGBA{0x80, 0x80, 0x80, 0xff} // rgb(128, 128, 128)
-	Green                = color.RGBA{0x00, 0x80, 0x00, 0xff} // rgb(0, 128, 0)
-	Greenyellow          = color.RGBA{0xad, 0xff, 0x2f, 0xff} // rgb(173, 255, 47)
-	Grey                 = color.RGBA{0x80, 0x80, 0x80, 0xff} // rgb(128, 128, 128)
-	Honeydew             = color.RGBA{0xf0, 0xff, 0xf0, 0xff} // rgb(240, 255, 240)
-	Hotpink              = color.RGBA{0xff, 0x69, 0xb4, 0xff} // rgb(255, 105, 180)
-	Indianred            = color.RGBA{0xcd, 0x5c, 0x5c, 0xff} // rgb(205, 92, 92)
-	Indigo               = color.RGBA{0x4b, 0x00, 0x82, 0xff} // rgb(75, 0, 130)
-	Ivory                = color.RGBA{0xff, 0xff, 0xf0, 0xff} // rgb(255, 255, 240)
-	Khaki                = color.RGBA{0xf0, 0xe6, 0x8c, 0xff} // rgb(240, 230, 140)
-	Lavender             = color.RGBA{0xe6, 0xe6, 0xfa, 0xff} // rgb(230, 230, 250)
-	Lavenderblush        = color.RGBA{0xff, 0xf0, 0xf5, 0xff} // rgb(255, 240, 245)
-	Lawngreen            = color.RGBA{0x7c, 0xfc, 0x00, 0xff} // rgb(124, 252, 0)
-	Lemonchiffon         = color.RGBA{0xff, 0xfa, 0xcd, 0xff} // rgb(255, 250, 205)
-	Lightblue            = color.RGBA{0xad, 0xd8, 0xe6, 0xff} // rgb(173, 216, 230)
-	Lightcoral           = color.RGBA{0xf0, 0x80, 0x80, 0xff} // rgb(240, 128, 128)
-	Lightcyan            = color.RGBA{0xe0, 0xff, 0xff, 0xff} // rgb(224, 255, 255)
-	Lightgoldenrodyellow = color.RGBA{0xfa, 0xfa, 0xd2, 0xff} // rgb(250, 250, 210)
-	Lightgray            = color.RGBA{0xd3, 0xd3, 0xd3, 0xff} // rgb(211, 211, 211)
-	Lightgreen           = color.RGBA{0x90, 0xee, 0x90, 0xff} // rgb(144, 238, 144)
-	Lightgrey            = color.RGBA{0xd3, 0xd3, 0xd3, 0xff} // rgb(211, 211, 211)
-	Lightpink            = color.RGBA{0xff, 0xb6, 0xc1, 0xff} // rgb(255, 182, 193)
-	Lightsalmon          = color.RGBA{0xff, 0xa0, 0x7a, 0xff} // rgb(255, 160, 122)
-	Lightseagreen        = color.RGBA{0x20, 0xb2, 0xaa, 0xff} // rgb(32, 178, 170)
-	Lightskyblue         = color.RGBA{0x87, 0xce, 0xfa, 0xff} // rgb(135, 206, 250)
-	Lightslategray       = color.RGBA{0x77, 0x88, 0x99, 0xff} // rgb(119, 136, 153)
-	Lightslategrey       = color.RGBA{0x77, 0x88, 0x99, 0xff} // rgb(119, 136, 153)
-	Lightsteelblue       = color.RGBA{0xb0, 0xc4, 0xde, 0xff} // rgb(176, 196, 222)
-	Lightyellow          = color.RGBA{0xff, 0xff, 0xe0, 0xff} // rgb(255, 255, 224)
-	Lime                 = color.RGBA{0x00, 0xff, 0x00, 0xff} // rgb(0, 255, 0)
-	Limegreen            = color.RGBA{0x32, 0xcd, 0x32, 0xff} // rgb(50, 205, 50)
-	Linen                = color.RGBA{0xfa, 0xf0, 0xe6, 0xff} // rgb(250, 240, 230)
-	Magenta              = color.RGBA{0xff, 0x00, 0xff, 0xff} // rgb(255, 0, 255)
-	Maroon               = color.RGBA{0x80, 0x00, 0x00, 0xff} // rgb(128, 0, 0)
-	Mediumaquamarine     = color.RGBA{0x66, 0xcd, 0xaa, 0xff} // rgb(102, 205, 170)
-	Mediumblue           = color.RGBA{0x00, 0x00, 0xcd, 0xff} // rgb(0, 0, 205)
-	Mediumorchid         = color.RGBA{0xba, 0x55, 0xd3, 0xff} // rgb(186, 85, 211)
-	Mediumpurple         = color.RGBA{0x93, 0x70, 0xdb, 0xff} // rgb(147, 112, 219)
-	Mediumseagreen       = color.RGBA{0x3c, 0xb3, 0x71, 0xff} // rgb(60, 179, 113)
-	Mediumslateblue      = color.RGBA{0x7b, 0x68, 0xee, 0xff} // rgb(123, 104, 238)
-	Mediumspringgreen    = color.RGBA{0x00, 0xfa, 0x9a, 0xff} // rgb(0, 250, 154)
-	Mediumturquoise      = color.RGBA{0x48, 0xd1, 0xcc, 0xff} // rgb(72, 209, 204)
-	Mediumvioletred      = color.RGBA{0xc7, 0x15, 0x85, 0xff} // rgb(199, 21, 133)
-	Midnightblue         = color.RGBA{0x19, 0x19, 0x70, 0xff} // rgb(25, 25, 112)
-	Mintcream            = color.RGBA{0xf5, 0xff, 0xfa, 0xff} // rgb(245, 255, 250)
-	Mistyrose            = color.RGBA{0xff, 0xe4, 0xe1, 0xff} // rgb(255, 228, 225)
-	Moccasin             = color.RGBA{0xff, 0xe4, 0xb5, 0xff} // rgb(255, 228, 181)
-	Navajowhite          = color.RGBA{0xff, 0xde, 0xad, 0xff} // rgb(255, 222, 173)
-	Navy                 = color.RGBA{0x00, 0x00, 0x80, 0xff} // rgb(0, 0, 128)
-	Oldlace              = color.RGBA{0xfd, 0xf5, 0xe6, 0xff} // rgb(253, 245, 230)
-	Olive                = color.RGBA{0x80, 0x80, 0x00, 0xff} // rgb(128, 128, 0)
-	Olivedrab            = color.RGBA{0x6b, 0x8e, 0x23, 0xff} // rgb(107, 142, 35)
-	Orange               = color.RGBA{0xff, 0xa5, 0x00, 0xff} // rgb(255, 165, 0)
-	Orangered            = color.RGBA{0xff, 0x45, 0x00, 0xff} // rgb(255, 69, 0)
-	Orchid               = color.RGBA{0xda, 0x70, 0xd6, 0xff} // rgb(218, 112, 214)
-	Palegoldenrod        = color.RGBA{0xee, 0xe8, 0xaa, 0xff} // rgb(238, 232, 170)
-	Palegreen            = color.RGBA{0x98, 0xfb, 0x98, 0xff} // rgb(152, 251, 152)
-	Paleturquoise        = color.RGBA{0xaf, 0xee, 0xee, 0xff} // rgb(175, 238, 238)
-	Palevioletred        = color.RGBA{0xdb, 0x70, 0x93, 0xff} // rgb(219, 112, 147)
-	Papayawhip           = color.RGBA{0xff, 0xef, 0xd5, 0xff} // rgb(255, 239, 213)
-	Peachpuff            = color.RGBA{0xff, 0xda, 0xb9, 0xff} // rgb(255, 218, 185)
-	Peru                 = color.RGBA{0xcd, 0x85, 0x3f, 0xff} // rgb(205, 133, 63)
-	Pink                 = color.RGBA{0xff, 0xc0, 0xcb, 0xff} // rgb(255, 192, 203)
-	Plum                 = color.RGBA{0xdd, 0xa0, 0xdd, 0xff} // rgb(221, 160, 221)
-	Powderblue           = color.RGBA{0xb0, 0xe0, 0xe6, 0xff} // rgb(176, 224, 230)
-	Purple               = color.RGBA{0x80, 0x00, 0x80, 0xff} // rgb(128, 0, 128)
-	Red                  = color.RGBA{0xff, 0x00, 0x00, 0xff} // rgb(255, 0, 0)
-	Rosybrown            = color.RGBA{0xbc, 0x8f, 0x8f, 0xff} // rgb(188, 143, 143)
-	Royalblue            = color.RGBA{0x41, 0x69, 0xe1, 0xff} // rgb(65, 105, 225)
-	Saddlebrown          = color.RGBA{0x8b, 0x45, 0x13, 0xff} // rgb(139, 69, 19)
-	Salmon               = color.RGBA{0xfa, 0x80, 0x72, 0xff} // rgb(250, 128, 114)
-	Sandybrown           = color.RGBA{0xf4, 0xa4, 0x60, 0xff} // rgb(244, 164, 96)
-	Seagreen             = color.RGBA{0x2e, 0x8b, 0x57, 0xff} // rgb(46, 139, 87)
-	Seashell             = color.RGBA{0xff, 0xf5, 0xee, 0xff} // rgb(255, 245, 238)
-	Sienna               = color.RGBA{0xa0, 0x52, 0x2d, 0xff} // rgb(160, 82, 45)
-	Silver               = color.RGBA{0xc0, 0xc0, 0xc0, 0xff} // rgb(192, 192, 192)
-	Skyblue              = color.RGBA{0x87, 0xce, 0xeb, 0xff} // rgb(135, 206, 235)
-	Slateblue            = color.RGBA{0x6a, 0x5a, 0xcd, 0xff} // rgb(106, 90, 205)
-	Slategray            = color.RGBA{0x70, 0x80, 0x90, 0xff} // rgb(112, 128, 144)
-	Slategrey            = color.RGBA{0x70, 0x80, 0x90, 0xff} // rgb(112, 128, 144)
-	Snow                 = color.RGBA{0xff, 0xfa, 0xfa, 0xff} // rgb(255, 250, 250)
-	Springgreen          = color.RGBA{0x00, 0xff, 0x7f, 0xff} // rgb(0, 255, 127)
-	Steelblue            = color.RGBA{0x46, 0x82, 0xb4, 0xff} // rgb(70, 130, 180)
-	Tan                  = color.RGBA{0xd2, 0xb4, 0x8c, 0xff} // rgb(210, 180, 140)
-	Teal                 = color.RGBA{0x00, 0x80, 0x80, 0xff} // rgb(0, 128, 128)
-	Thistle              = color.RGBA{0xd8, 0xbf, 0xd8, 0xff} // rgb(216, 191, 216)
-	Tomato               = color.RGBA{0xff, 0x63, 0x47, 0xff} // rgb(255, 99, 71)
-	Turquoise            = color.RGBA{0x40, 0xe0, 0xd0, 0xff} // rgb(64, 224, 208)
-	Violet               = color.RGBA{0xee, 0x82, 0xee, 0xff} // rgb(238, 130, 238)
-	Wheat                = color.RGBA{0xf5, 0xde, 0xb3, 0xff} // rgb(245, 222, 179)
-	White                = color.RGBA{0xff, 0xff, 0xff, 0xff} // rgb(255, 255, 255)
-	Whitesmoke           = color.RGBA{0xf5, 0xf5, 0xf5, 0xff} // rgb(245, 245, 245)
-	Yellow               = color.RGBA{0xff, 0xff, 0x00, 0xff} // rgb(255, 255, 0)
-	Yellowgreen          = color.RGBA{0x9a, 0xcd, 0x32, 0xff} // rgb(154, 205, 50)
-)

vendor/golang.org/x/image/draw/draw.go

@@ -1,43 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package draw provides image composition functions.
-//
-// See "The Go image/draw package" for an introduction to this package:
-// http://golang.org/doc/articles/image_draw.html
-//
-// This package is a superset of and a drop-in replacement for the image/draw
-// package in the standard library.
-package draw
-
-// This file, and the go1_*.go files, just contains the API exported by the
-// image/draw package in the standard library. Other files in this package
-// provide additional features.
-
-import (
-	"image"
-	"image/draw"
-)
-
-// Draw calls DrawMask with a nil mask.
-func Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point, op Op) {
-	draw.Draw(dst, r, src, sp, draw.Op(op))
-}
-
-// DrawMask aligns r.Min in dst with sp in src and mp in mask and then
-// replaces the rectangle r in dst with the result of a Porter-Duff
-// composition. A nil mask is treated as opaque.
-func DrawMask(dst Image, r image.Rectangle, src image.Image, sp image.Point, mask image.Image, mp image.Point, op Op) {
-	draw.DrawMask(dst, r, src, sp, mask, mp, draw.Op(op))
-}
-
-// FloydSteinberg is a Drawer that is the Src Op with Floyd-Steinberg error
-// diffusion.
-var FloydSteinberg Drawer = floydSteinberg{}
-
-type floydSteinberg struct{}
-
-func (floydSteinberg) Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point) {
-	draw.FloydSteinberg.Draw(dst, r, src, sp)
-}

vendor/golang.org/x/image/draw/example_test.go

@@ -1,118 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package draw_test
-
-import (
-	"fmt"
-	"image"
-	"image/color"
-	"image/png"
-	"log"
-	"math"
-	"os"
-
-	"golang.org/x/image/draw"
-	"golang.org/x/image/math/f64"
-)
-
-func ExampleDraw() {
-	fSrc, err := os.Open("../testdata/blue-purple-pink.png")
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer fSrc.Close()
-	src, err := png.Decode(fSrc)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	dst := image.NewRGBA(image.Rect(0, 0, 400, 300))
-	green := image.NewUniform(color.RGBA{0x00, 0x1f, 0x00, 0xff})
-	draw.Copy(dst, image.Point{}, green, dst.Bounds(), draw.Src, nil)
-	qs := []draw.Interpolator{
-		draw.NearestNeighbor,
-		draw.ApproxBiLinear,
-		draw.CatmullRom,
-	}
-	const cos60, sin60 = 0.5, 0.866025404
-	t := f64.Aff3{
-		+2 * cos60, -2 * sin60, 100,
-		+2 * sin60, +2 * cos60, 100,
-	}
-
-	draw.Copy(dst, image.Point{20, 30}, src, src.Bounds(), draw.Over, nil)
-	for i, q := range qs {
-		q.Scale(dst, image.Rect(200+10*i, 100*i, 600+10*i, 150+100*i), src, src.Bounds(), draw.Over, nil)
-	}
-	draw.NearestNeighbor.Transform(dst, t, src, src.Bounds(), draw.Over, nil)
-
-	red := image.NewNRGBA(image.Rect(0, 0, 16, 16))
-	for y := 0; y < 16; y++ {
-		for x := 0; x < 16; x++ {
-			red.SetNRGBA(x, y, color.NRGBA{
-				R: uint8(x * 0x11),
-				A: uint8(y * 0x11),
-			})
-		}
-	}
-	red.SetNRGBA(0, 0, color.NRGBA{0xff, 0xff, 0x00, 0xff})
-	red.SetNRGBA(15, 15, color.NRGBA{0xff, 0xff, 0x00, 0xff})
-
-	ops := []draw.Op{
-		draw.Over,
-		draw.Src,
-	}
-	for i, op := range ops {
-		dr := image.Rect(120+10*i, 150+60*i, 170+10*i, 200+60*i)
-		draw.NearestNeighbor.Scale(dst, dr, red, red.Bounds(), op, nil)
-		t := f64.Aff3{
-			+cos60, -sin60, float64(190 + 10*i),
-			+sin60, +cos60, float64(140 + 50*i),
-		}
-		draw.NearestNeighbor.Transform(dst, t, red, red.Bounds(), op, nil)
-	}
-
-	dr := image.Rect(0, 0, 128, 128)
-	checkerboard := image.NewAlpha(dr)
-	for y := dr.Min.Y; y < dr.Max.Y; y++ {
-		for x := dr.Min.X; x < dr.Max.X; x++ {
-			if (x/20)%2 == (y/20)%2 {
-				checkerboard.SetAlpha(x, y, color.Alpha{0xff})
-			}
-		}
-	}
-	sr := image.Rect(0, 0, 16, 16)
-	circle := image.NewAlpha(sr)
-	for y := sr.Min.Y; y < sr.Max.Y; y++ {
-		for x := sr.Min.X; x < sr.Max.X; x++ {
-			dx, dy := x-10, y-8
-			if d := 32 * math.Sqrt(float64(dx*dx)+float64(dy*dy)); d < 0xff {
-				circle.SetAlpha(x, y, color.Alpha{0xff - uint8(d)})
-			}
-		}
-	}
-	cyan := image.NewUniform(color.RGBA{0x00, 0xff, 0xff, 0xff})
-	draw.NearestNeighbor.Scale(dst, dr, cyan, sr, draw.Over, &draw.Options{
-		DstMask: checkerboard,
-		SrcMask: circle,
-	})
-
-	// Change false to true to write the resultant image to disk.
-	if false {
-		fDst, err := os.Create("out.png")
-		if err != nil {
-			log.Fatal(err)
-		}
-		defer fDst.Close()
-		err = png.Encode(fDst, dst)
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-
-	fmt.Printf("dst has bounds %v.\n", dst.Bounds())
-	// Output:
-	// dst has bounds (0,0)-(400,300).
-}

vendor/golang.org/x/image/draw/go1_8.go

@@ -1,49 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !go1.9,!go1.8.typealias
-
-package draw
-
-import (
-	"image"
-	"image/color"
-	"image/draw"
-)
-
-// Drawer contains the Draw method.
-type Drawer interface {
-	// Draw aligns r.Min in dst with sp in src and then replaces the
-	// rectangle r in dst with the result of drawing src on dst.
-	Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point)
-}
-
-// Image is an image.Image with a Set method to change a single pixel.
-type Image interface {
-	image.Image
-	Set(x, y int, c color.Color)
-}
-
-// Op is a Porter-Duff compositing operator.
-type Op int
-
-const (
-	// Over specifies ``(src in mask) over dst''.
-	Over Op = Op(draw.Over)
-	// Src specifies ``src in mask''.
-	Src Op = Op(draw.Src)
-)
-
-// Draw implements the Drawer interface by calling the Draw function with
-// this Op.
-func (op Op) Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point) {
-	(draw.Op(op)).Draw(dst, r, src, sp)
-}
-
-// Quantizer produces a palette for an image.
-type Quantizer interface {
-	// Quantize appends up to cap(p) - len(p) colors to p and returns the
-	// updated palette suitable for converting m to a paletted image.
-	Quantize(p color.Palette, m image.Image) color.Palette
-}

vendor/golang.org/x/image/draw/go1_9.go

@@ -1,57 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build go1.9 go1.8.typealias
-
-package draw
-
-import (
-	"image/draw"
-)
-
-// We use type aliases (new in Go 1.9) for the exported names from the standard
-// library's image/draw package. This is not merely syntactic sugar for
-//
-//	type Drawer draw.Drawer
-//
-// as aliasing means that the types in this package, such as draw.Image and
-// draw.Op, are identical to the corresponding draw.Image and draw.Op types in
-// the standard library. In comparison, prior to Go 1.9, the code in go1_8.go
-// defines new types that mimic the old but are different types.
-//
-// The package documentation, in draw.go, explicitly gives the intent of this
-// package:
-//
-//	This package is a superset of and a drop-in replacement for the
-//	image/draw package in the standard library.
-//
-// Drop-in replacement means that I can replace all of my "image/draw" imports
-// with "golang.org/x/image/draw", to access additional features in this
-// package, and no further changes are required. That's mostly true, but not
-// completely true unless we use type aliases.
-//
-// Without type aliases, users might need to import both "image/draw" and
-// "golang.org/x/image/draw" in order to convert from two conceptually
-// equivalent but different (from the compiler's point of view) types, such as
-// from one draw.Op type to another draw.Op type, to satisfy some other
-// interface or function signature.
-
-// Drawer contains the Draw method.
-type Drawer = draw.Drawer
-
-// Image is an image.Image with a Set method to change a single pixel.
-type Image = draw.Image
-
-// Op is a Porter-Duff compositing operator.
-type Op = draw.Op
-
-const (
-	// Over specifies ``(src in mask) over dst''.
-	Over Op = draw.Over
-	// Src specifies ``src in mask''.
-	Src Op = draw.Src
-)
-
-// Quantizer produces a palette for an image.
-type Quantizer = draw.Quantizer

vendor/golang.org/x/image/draw/scale.go

@@ -1,527 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:generate go run gen.go
-
-package draw
-
-import (
-	"image"
-	"image/color"
-	"math"
-	"sync"
-
-	"golang.org/x/image/math/f64"
-)
-
-// Copy copies the part of the source image defined by src and sr and writes
-// the result of a Porter-Duff composition to the part of the destination image
-// defined by dst and the translation of sr so that sr.Min translates to dp.
-func Copy(dst Image, dp image.Point, src image.Image, sr image.Rectangle, op Op, opts *Options) {
-	var o Options
-	if opts != nil {
-		o = *opts
-	}
-	dr := sr.Add(dp.Sub(sr.Min))
-	if o.DstMask == nil {
-		DrawMask(dst, dr, src, sr.Min, o.SrcMask, o.SrcMaskP.Add(sr.Min), op)
-	} else {
-		NearestNeighbor.Scale(dst, dr, src, sr, op, opts)
-	}
-}
-
-// Scaler scales the part of the source image defined by src and sr and writes
-// the result of a Porter-Duff composition to the part of the destination image
-// defined by dst and dr.
-//
-// A Scaler is safe to use concurrently.
-type Scaler interface {
-	Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options)
-}
-
-// Transformer transforms the part of the source image defined by src and sr
-// and writes the result of a Porter-Duff composition to the part of the
-// destination image defined by dst and the affine transform m applied to sr.
-//
-// For example, if m is the matrix
-//
-// m00 m01 m02
-// m10 m11 m12
-//
-// then the src-space point (sx, sy) maps to the dst-space point
-// (m00*sx + m01*sy + m02, m10*sx + m11*sy + m12).
-//
-// A Transformer is safe to use concurrently.
-type Transformer interface {
-	Transform(dst Image, m f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options)
-}
-
-// Options are optional parameters to Copy, Scale and Transform.
-//
-// A nil *Options means to use the default (zero) values of each field.
-type Options struct {
-	// Masks limit what parts of the dst image are drawn to and what parts of
-	// the src image are drawn from.
-	//
-	// A dst or src mask image having a zero alpha (transparent) pixel value in
-	// the respective coordinate space means that that dst pixel is entirely
-	// unaffected or that src pixel is considered transparent black. A full
-	// alpha (opaque) value means that the dst pixel is maximally affected or
-	// the src pixel contributes maximally. The default values, nil, are
-	// equivalent to fully opaque, infinitely large mask images.
-	//
-	// The DstMask is otherwise known as a clip mask, and its pixels map 1:1 to
-	// the dst image's pixels. DstMaskP in DstMask space corresponds to
-	// image.Point{X:0, Y:0} in dst space. For example, when limiting
-	// repainting to a 'dirty rectangle', use that image.Rectangle and a zero
-	// image.Point as the DstMask and DstMaskP.
-	//
-	// The SrcMask's pixels map 1:1 to the src image's pixels. SrcMaskP in
-	// SrcMask space corresponds to image.Point{X:0, Y:0} in src space. For
-	// example, when drawing font glyphs in a uniform color, use an
-	// *image.Uniform as the src, and use the glyph atlas image and the
-	// per-glyph offset as SrcMask and SrcMaskP:
-	//	Copy(dst, dp, image.NewUniform(color), image.Rect(0, 0, glyphWidth, glyphHeight), &Options{
-	//		SrcMask:  glyphAtlas,
-	//		SrcMaskP: glyphOffset,
-	//	})
-	DstMask  image.Image
-	DstMaskP image.Point
-	SrcMask  image.Image
-	SrcMaskP image.Point
-
-	// TODO: a smooth vs sharp edges option, for arbitrary rotations?
-}
-
-// Interpolator is an interpolation algorithm, when dst and src pixels don't
-// have a 1:1 correspondence.
-//
-// Of the interpolators provided by this package:
-//	- NearestNeighbor is fast but usually looks worst.
-//	- CatmullRom is slow but usually looks best.
-//	- ApproxBiLinear has reasonable speed and quality.
-//
-// The time taken depends on the size of dr. For kernel interpolators, the
-// speed also depends on the size of sr, and so are often slower than
-// non-kernel interpolators, especially when scaling down.
-type Interpolator interface {
-	Scaler
-	Transformer
-}
-
-// Kernel is an interpolator that blends source pixels weighted by a symmetric
-// kernel function.
-type Kernel struct {
-	// Support is the kernel support and must be >= 0. At(t) is assumed to be
-	// zero when t >= Support.
-	Support float64
-	// At is the kernel function. It will only be called with t in the
-	// range [0, Support).
-	At func(t float64) float64
-}
-
-// Scale implements the Scaler interface.
-func (q *Kernel) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) {
-	q.newScaler(dr.Dx(), dr.Dy(), sr.Dx(), sr.Dy(), false).Scale(dst, dr, src, sr, op, opts)
-}
-
-// NewScaler returns a Scaler that is optimized for scaling multiple times with
-// the same fixed destination and source width and height.
-func (q *Kernel) NewScaler(dw, dh, sw, sh int) Scaler {
-	return q.newScaler(dw, dh, sw, sh, true)
-}
-
-func (q *Kernel) newScaler(dw, dh, sw, sh int, usePool bool) Scaler {
-	z := &kernelScaler{
-		kernel:     q,
-		dw:         int32(dw),
-		dh:         int32(dh),
-		sw:         int32(sw),
-		sh:         int32(sh),
-		horizontal: newDistrib(q, int32(dw), int32(sw)),
-		vertical:   newDistrib(q, int32(dh), int32(sh)),
-	}
-	if usePool {
-		z.pool.New = func() interface{} {
-			tmp := z.makeTmpBuf()
-			return &tmp
-		}
-	}
-	return z
-}
-
-var (
-	// NearestNeighbor is the nearest neighbor interpolator. It is very fast,
-	// but usually gives very low quality results. When scaling up, the result
-	// will look 'blocky'.
-	NearestNeighbor = Interpolator(nnInterpolator{})
-
-	// ApproxBiLinear is a mixture of the nearest neighbor and bi-linear
-	// interpolators. It is fast, but usually gives medium quality results.
-	//
-	// It implements bi-linear interpolation when upscaling and a bi-linear
-	// blend of the 4 nearest neighbor pixels when downscaling. This yields
-	// nicer quality than nearest neighbor interpolation when upscaling, but
-	// the time taken is independent of the number of source pixels, unlike the
-	// bi-linear interpolator. When downscaling a large image, the performance
-	// difference can be significant.
-	ApproxBiLinear = Interpolator(ablInterpolator{})
-
-	// BiLinear is the tent kernel. It is slow, but usually gives high quality
-	// results.
-	BiLinear = &Kernel{1, func(t float64) float64 {
-		return 1 - t
-	}}
-
-	// CatmullRom is the Catmull-Rom kernel. It is very slow, but usually gives
-	// very high quality results.
-	//
-	// It is an instance of the more general cubic BC-spline kernel with parameters
-	// B=0 and C=0.5. See Mitchell and Netravali, "Reconstruction Filters in
-	// Computer Graphics", Computer Graphics, Vol. 22, No. 4, pp. 221-228.
-	CatmullRom = &Kernel{2, func(t float64) float64 {
-		if t < 1 {
-			return (1.5*t-2.5)*t*t + 1
-		}
-		return ((-0.5*t+2.5)*t-4)*t + 2
-	}}
-
-	// TODO: a Kaiser-Bessel kernel?
-)
-
-type nnInterpolator struct{}
-
-type ablInterpolator struct{}
-
-type kernelScaler struct {
-	kernel               *Kernel
-	dw, dh, sw, sh       int32
-	horizontal, vertical distrib
-	pool                 sync.Pool
-}
-
-func (z *kernelScaler) makeTmpBuf() [][4]float64 {
-	return make([][4]float64, z.dw*z.sh)
-}
-
-// source is a range of contribs, their inverse total weight, and that ITW
-// divided by 0xffff.
-type source struct {
-	i, j               int32
-	invTotalWeight     float64
-	invTotalWeightFFFF float64
-}
-
-// contrib is the weight of a column or row.
-type contrib struct {
-	coord  int32
-	weight float64
-}
-
-// distrib measures how source pixels are distributed over destination pixels.
-type distrib struct {
-	// sources are what contribs each column or row in the source image owns,
-	// and the total weight of those contribs.
-	sources []source
-	// contribs are the contributions indexed by sources[s].i and sources[s].j.
-	contribs []contrib
-}
-
-// newDistrib returns a distrib that distributes sw source columns (or rows)
-// over dw destination columns (or rows).
-func newDistrib(q *Kernel, dw, sw int32) distrib {
-	scale := float64(sw) / float64(dw)
-	halfWidth, kernelArgScale := q.Support, 1.0
-	// When shrinking, broaden the effective kernel support so that we still
-	// visit every source pixel.
-	if scale > 1 {
-		halfWidth *= scale
-		kernelArgScale = 1 / scale
-	}
-
-	// Make the sources slice, one source for each column or row, and temporarily
-	// appropriate its elements' fields so that invTotalWeight is the scaled
-	// coordinate of the source column or row, and i and j are the lower and
-	// upper bounds of the range of destination columns or rows affected by the
-	// source column or row.
-	n, sources := int32(0), make([]source, dw)
-	for x := range sources {
-		center := (float64(x)+0.5)*scale - 0.5
-		i := int32(math.Floor(center - halfWidth))
-		if i < 0 {
-			i = 0
-		}
-		j := int32(math.Ceil(center + halfWidth))
-		if j > sw {
-			j = sw
-			if j < i {
-				j = i
-			}
-		}
-		sources[x] = source{i: i, j: j, invTotalWeight: center}
-		n += j - i
-	}
-
-	contribs := make([]contrib, 0, n)
-	for k, b := range sources {
-		totalWeight := 0.0
-		l := int32(len(contribs))
-		for coord := b.i; coord < b.j; coord++ {
-			t := abs((b.invTotalWeight - float64(coord)) * kernelArgScale)
-			if t >= q.Support {
-				continue
-			}
-			weight := q.At(t)
-			if weight == 0 {
-				continue
-			}
-			totalWeight += weight
-			contribs = append(contribs, contrib{coord, weight})
-		}
-		totalWeight = 1 / totalWeight
-		sources[k] = source{
-			i:                  l,
-			j:                  int32(len(contribs)),
-			invTotalWeight:     totalWeight,
-			invTotalWeightFFFF: totalWeight / 0xffff,
-		}
-	}
-
-	return distrib{sources, contribs}
-}
-
-// abs is like math.Abs, but it doesn't care about negative zero, infinities or
-// NaNs.
-func abs(f float64) float64 {
-	if f < 0 {
-		f = -f
-	}
-	return f
-}
-
-// ftou converts the range [0.0, 1.0] to [0, 0xffff].
-func ftou(f float64) uint16 {
-	i := int32(0xffff*f + 0.5)
-	if i > 0xffff {
-		return 0xffff
-	}
-	if i > 0 {
-		return uint16(i)
-	}
-	return 0
-}
-
-// fffftou converts the range [0.0, 65535.0] to [0, 0xffff].
-func fffftou(f float64) uint16 {
-	i := int32(f + 0.5)
-	if i > 0xffff {
-		return 0xffff
-	}
-	if i > 0 {
-		return uint16(i)
-	}
-	return 0
-}
-
-// invert returns the inverse of m.
-//
-// TODO: move this into the f64 package, once we work out the convention for
-// matrix methods in that package: do they modify the receiver, take a dst
-// pointer argument, or return a new value?
-func invert(m *f64.Aff3) f64.Aff3 {
-	m00 := +m[3*1+1]
-	m01 := -m[3*0+1]
-	m02 := +m[3*1+2]*m[3*0+1] - m[3*1+1]*m[3*0+2]
-	m10 := -m[3*1+0]
-	m11 := +m[3*0+0]
-	m12 := +m[3*1+0]*m[3*0+2] - m[3*1+2]*m[3*0+0]
-
-	det := m00*m11 - m10*m01
-
-	return f64.Aff3{
-		m00 / det,
-		m01 / det,
-		m02 / det,
-		m10 / det,
-		m11 / det,
-		m12 / det,
-	}
-}
-
-func matMul(p, q *f64.Aff3) f64.Aff3 {
-	return f64.Aff3{
-		p[3*0+0]*q[3*0+0] + p[3*0+1]*q[3*1+0],
-		p[3*0+0]*q[3*0+1] + p[3*0+1]*q[3*1+1],
-		p[3*0+0]*q[3*0+2] + p[3*0+1]*q[3*1+2] + p[3*0+2],
-		p[3*1+0]*q[3*0+0] + p[3*1+1]*q[3*1+0],
-		p[3*1+0]*q[3*0+1] + p[3*1+1]*q[3*1+1],
-		p[3*1+0]*q[3*0+2] + p[3*1+1]*q[3*1+2] + p[3*1+2],
-	}
-}
-
-// transformRect returns a rectangle dr that contains sr transformed by s2d.
-func transformRect(s2d *f64.Aff3, sr *image.Rectangle) (dr image.Rectangle) {
-	ps := [...]image.Point{
-		{sr.Min.X, sr.Min.Y},
-		{sr.Max.X, sr.Min.Y},
-		{sr.Min.X, sr.Max.Y},
-		{sr.Max.X, sr.Max.Y},
-	}
-	for i, p := range ps {
-		sxf := float64(p.X)
-		syf := float64(p.Y)
-		dx := int(math.Floor(s2d[0]*sxf + s2d[1]*syf + s2d[2]))
-		dy := int(math.Floor(s2d[3]*sxf + s2d[4]*syf + s2d[5]))
-
-		// The +1 adjustments below are because an image.Rectangle is inclusive
-		// on the low end but exclusive on the high end.
-
-		if i == 0 {
-			dr = image.Rectangle{
-				Min: image.Point{dx + 0, dy + 0},
-				Max: image.Point{dx + 1, dy + 1},
-			}
-			continue
-		}
-
-		if dr.Min.X > dx {
-			dr.Min.X = dx
-		}
-		dx++
-		if dr.Max.X < dx {
-			dr.Max.X = dx
-		}
-
-		if dr.Min.Y > dy {
-			dr.Min.Y = dy
-		}
-		dy++
-		if dr.Max.Y < dy {
-			dr.Max.Y = dy
-		}
-	}
-	return dr
-}
-
-func clipAffectedDestRect(adr image.Rectangle, dstMask image.Image, dstMaskP image.Point) (image.Rectangle, image.Image) {
-	if dstMask == nil {
-		return adr, nil
-	}
-	// TODO: enable this fast path once Go 1.5 is released, where an
-	// image.Rectangle implements image.Image.
-	// if r, ok := dstMask.(image.Rectangle); ok {
-	// 	return adr.Intersect(r.Sub(dstMaskP)), nil
-	// }
-	// TODO: clip to dstMask.Bounds() if the color model implies that out-of-bounds means 0 alpha?
-	return adr, dstMask
-}
-
-func transform_Uniform(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Uniform, sr image.Rectangle, bias image.Point, op Op) {
-	switch op {
-	case Over:
-		switch dst := dst.(type) {
-		case *image.RGBA:
-			pr, pg, pb, pa := src.C.RGBA()
-			pa1 := (0xffff - pa) * 0x101
-
-			for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
-				dyf := float64(dr.Min.Y+int(dy)) + 0.5
-				d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))
-				for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
-					dxf := float64(dr.Min.X+int(dx)) + 0.5
-					sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X
-					sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y
-					if !(image.Point{sx0, sy0}).In(sr) {
-						continue
-					}
-					dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr) >> 8)
-					dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg) >> 8)
-					dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb) >> 8)
-					dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa) >> 8)
-				}
-			}
-
-		default:
-			pr, pg, pb, pa := src.C.RGBA()
-			pa1 := 0xffff - pa
-			dstColorRGBA64 := &color.RGBA64{}
-			dstColor := color.Color(dstColorRGBA64)
-
-			for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
-				dyf := float64(dr.Min.Y+int(dy)) + 0.5
-				for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
-					dxf := float64(dr.Min.X+int(dx)) + 0.5
-					sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X
-					sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y
-					if !(image.Point{sx0, sy0}).In(sr) {
-						continue
-					}
-					qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA()
-					dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr)
-					dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg)
-					dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb)
-					dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa)
-					dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor)
-				}
-			}
-		}
-
-	case Src:
-		switch dst := dst.(type) {
-		case *image.RGBA:
-			pr, pg, pb, pa := src.C.RGBA()
-			pr8 := uint8(pr >> 8)
-			pg8 := uint8(pg >> 8)
-			pb8 := uint8(pb >> 8)
-			pa8 := uint8(pa >> 8)
-
-			for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
-				dyf := float64(dr.Min.Y+int(dy)) + 0.5
-				d := dst.PixOffset(dr.Min.X+adr.Min.X, dr.Min.Y+int(dy))
-				for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
-					dxf := float64(dr.Min.X+int(dx)) + 0.5
-					sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X
-					sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y
-					if !(image.Point{sx0, sy0}).In(sr) {
-						continue
-					}
-					dst.Pix[d+0] = pr8
-					dst.Pix[d+1] = pg8
-					dst.Pix[d+2] = pb8
-					dst.Pix[d+3] = pa8
-				}
-			}
-
-		default:
-			pr, pg, pb, pa := src.C.RGBA()
-			dstColorRGBA64 := &color.RGBA64{
-				uint16(pr),
-				uint16(pg),
-				uint16(pb),
-				uint16(pa),
-			}
-			dstColor := color.Color(dstColorRGBA64)
-
-			for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
-				dyf := float64(dr.Min.Y+int(dy)) + 0.5
-				for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
-					dxf := float64(dr.Min.X+int(dx)) + 0.5
-					sx0 := int(d2s[0]*dxf+d2s[1]*dyf+d2s[2]) + bias.X
-					sy0 := int(d2s[3]*dxf+d2s[4]*dyf+d2s[5]) + bias.Y
-					if !(image.Point{sx0, sy0}).In(sr) {
-						continue
-					}
-					dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor)
-				}
-			}
-		}
-	}
-}
-
-func opaque(m image.Image) bool {
-	o, ok := m.(interface {
-		Opaque() bool
-	})
-	return ok && o.Opaque()
-}

vendor/golang.org/x/image/draw/scale_test.go

@@ -1,742 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package draw
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"image"
-	"image/color"
-	"image/png"
-	"math/rand"
-	"os"
-	"reflect"
-	"testing"
-
-	"golang.org/x/image/math/f64"
-
-	_ "image/jpeg"
-)
-
-var genGoldenFiles = flag.Bool("gen_golden_files", false, "whether to generate the TestXxx golden files.")
-
-var transformMatrix = func(scale, tx, ty float64) f64.Aff3 {
-	const cos30, sin30 = 0.866025404, 0.5
-	return f64.Aff3{
-		+scale * cos30, -scale * sin30, tx,
-		+scale * sin30, +scale * cos30, ty,
-	}
-}
-
-func encode(filename string, m image.Image) error {
-	f, err := os.Create(filename)
-	if err != nil {
-		return fmt.Errorf("Create: %v", err)
-	}
-	defer f.Close()
-	if err := png.Encode(f, m); err != nil {
-		return fmt.Errorf("Encode: %v", err)
-	}
-	return nil
-}
-
-// testInterp tests that interpolating the source image gives the exact
-// destination image. This is to ensure that any refactoring or optimization of
-// the interpolation code doesn't change the behavior. Changing the actual
-// algorithm or kernel used by any particular quality setting will obviously
-// change the resultant pixels. In such a case, use the gen_golden_files flag
-// to regenerate the golden files.
-func testInterp(t *testing.T, w int, h int, direction, prefix, suffix string) {
-	f, err := os.Open("../testdata/" + prefix + suffix)
-	if err != nil {
-		t.Fatalf("Open: %v", err)
-	}
-	defer f.Close()
-	src, _, err := image.Decode(f)
-	if err != nil {
-		t.Fatalf("Decode: %v", err)
-	}
-
-	op, scale := Src, 3.75
-	if prefix == "tux" {
-		op, scale = Over, 0.125
-	}
-	green := image.NewUniform(color.RGBA{0x00, 0x22, 0x11, 0xff})
-
-	testCases := map[string]Interpolator{
-		"nn": NearestNeighbor,
-		"ab": ApproxBiLinear,
-		"bl": BiLinear,
-		"cr": CatmullRom,
-	}
-	for name, q := range testCases {
-		goldenFilename := fmt.Sprintf("../testdata/%s-%s-%s.png", prefix, direction, name)
-
-		got := image.NewRGBA(image.Rect(0, 0, w, h))
-		Copy(got, image.Point{}, green, got.Bounds(), Src, nil)
-		if direction == "rotate" {
-			q.Transform(got, transformMatrix(scale, 40, 10), src, src.Bounds(), op, nil)
-		} else {
-			q.Scale(got, got.Bounds(), src, src.Bounds(), op, nil)
-		}
-
-		if *genGoldenFiles {
-			if err := encode(goldenFilename, got); err != nil {
-				t.Error(err)
-			}
-			continue
-		}
-
-		g, err := os.Open(goldenFilename)
-		if err != nil {
-			t.Errorf("Open: %v", err)
-			continue
-		}
-		defer g.Close()
-		wantRaw, err := png.Decode(g)
-		if err != nil {
-			t.Errorf("Decode: %v", err)
-			continue
-		}
-		// convert wantRaw to RGBA.
-		want, ok := wantRaw.(*image.RGBA)
-		if !ok {
-			b := wantRaw.Bounds()
-			want = image.NewRGBA(b)
-			Draw(want, b, wantRaw, b.Min, Src)
-		}
-
-		if !reflect.DeepEqual(got, want) {
-			t.Errorf("%s: actual image differs from golden image", goldenFilename)
-			continue
-		}
-	}
-}
-
-func TestScaleDown(t *testing.T) { testInterp(t, 100, 100, "down", "go-turns-two", "-280x360.jpeg") }
-func TestScaleUp(t *testing.T)   { testInterp(t, 75, 100, "up", "go-turns-two", "-14x18.png") }
-func TestTformSrc(t *testing.T)  { testInterp(t, 100, 100, "rotate", "go-turns-two", "-14x18.png") }
-func TestTformOver(t *testing.T) { testInterp(t, 100, 100, "rotate", "tux", ".png") }
-
-// TestSimpleTransforms tests Scale and Transform calls that simplify to Copy
-// or Scale calls.
-func TestSimpleTransforms(t *testing.T) {
-	f, err := os.Open("../testdata/testpattern.png") // A 100x100 image.
-	if err != nil {
-		t.Fatalf("Open: %v", err)
-	}
-	defer f.Close()
-	src, _, err := image.Decode(f)
-	if err != nil {
-		t.Fatalf("Decode: %v", err)
-	}
-
-	dst0 := image.NewRGBA(image.Rect(0, 0, 120, 150))
-	dst1 := image.NewRGBA(image.Rect(0, 0, 120, 150))
-	for _, op := range []string{"scale/copy", "tform/copy", "tform/scale"} {
-		for _, epsilon := range []float64{0, 1e-50, 1e-1} {
-			Copy(dst0, image.Point{}, image.Transparent, dst0.Bounds(), Src, nil)
-			Copy(dst1, image.Point{}, image.Transparent, dst1.Bounds(), Src, nil)
-
-			switch op {
-			case "scale/copy":
-				dr := image.Rect(10, 30, 10+100, 30+100)
-				if epsilon > 1e-10 {
-					dr.Max.X++
-				}
-				Copy(dst0, image.Point{10, 30}, src, src.Bounds(), Src, nil)
-				ApproxBiLinear.Scale(dst1, dr, src, src.Bounds(), Src, nil)
-			case "tform/copy":
-				Copy(dst0, image.Point{10, 30}, src, src.Bounds(), Src, nil)
-				ApproxBiLinear.Transform(dst1, f64.Aff3{
-					1, 0 + epsilon, 10,
-					0, 1, 30,
-				}, src, src.Bounds(), Src, nil)
-			case "tform/scale":
-				ApproxBiLinear.Scale(dst0, image.Rect(10, 50, 10+50, 50+50), src, src.Bounds(), Src, nil)
-				ApproxBiLinear.Transform(dst1, f64.Aff3{
-					0.5, 0.0 + epsilon, 10,
-					0.0, 0.5, 50,
-				}, src, src.Bounds(), Src, nil)
-			}
-
-			differ := !bytes.Equal(dst0.Pix, dst1.Pix)
-			if epsilon > 1e-10 {
-				if !differ {
-					t.Errorf("%s yielded same pixels, want different pixels: epsilon=%v", op, epsilon)
-				}
-			} else {
-				if differ {
-					t.Errorf("%s yielded different pixels, want same pixels: epsilon=%v", op, epsilon)
-				}
-			}
-		}
-	}
-}
-
-func BenchmarkSimpleScaleCopy(b *testing.B) {
-	dst := image.NewRGBA(image.Rect(0, 0, 640, 480))
-	src := image.NewRGBA(image.Rect(0, 0, 400, 300))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		ApproxBiLinear.Scale(dst, image.Rect(10, 20, 10+400, 20+300), src, src.Bounds(), Src, nil)
-	}
-}
-
-func BenchmarkSimpleTransformCopy(b *testing.B) {
-	dst := image.NewRGBA(image.Rect(0, 0, 640, 480))
-	src := image.NewRGBA(image.Rect(0, 0, 400, 300))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		ApproxBiLinear.Transform(dst, f64.Aff3{
-			1, 0, 10,
-			0, 1, 20,
-		}, src, src.Bounds(), Src, nil)
-	}
-}
-
-func BenchmarkSimpleTransformScale(b *testing.B) {
-	dst := image.NewRGBA(image.Rect(0, 0, 640, 480))
-	src := image.NewRGBA(image.Rect(0, 0, 400, 300))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		ApproxBiLinear.Transform(dst, f64.Aff3{
-			0.5, 0.0, 10,
-			0.0, 0.5, 20,
-		}, src, src.Bounds(), Src, nil)
-	}
-}
-
-func TestOps(t *testing.T) {
-	blue := image.NewUniform(color.RGBA{0x00, 0x00, 0xff, 0xff})
-	testCases := map[Op]color.RGBA{
-		Over: color.RGBA{0x7f, 0x00, 0x80, 0xff},
-		Src:  color.RGBA{0x7f, 0x00, 0x00, 0x7f},
-	}
-	for op, want := range testCases {
-		dst := image.NewRGBA(image.Rect(0, 0, 2, 2))
-		Copy(dst, image.Point{}, blue, dst.Bounds(), Src, nil)
-
-		src := image.NewRGBA(image.Rect(0, 0, 1, 1))
-		src.SetRGBA(0, 0, color.RGBA{0x7f, 0x00, 0x00, 0x7f})
-
-		NearestNeighbor.Scale(dst, dst.Bounds(), src, src.Bounds(), op, nil)
-
-		if got := dst.RGBAAt(0, 0); got != want {
-			t.Errorf("op=%v: got %v, want %v", op, got, want)
-		}
-	}
-}
-
-// TestNegativeWeights tests that scaling by a kernel that produces negative
-// weights, such as the Catmull-Rom kernel, doesn't produce an invalid color
-// according to Go's alpha-premultiplied model.
-func TestNegativeWeights(t *testing.T) {
-	check := func(m *image.RGBA) error {
-		b := m.Bounds()
-		for y := b.Min.Y; y < b.Max.Y; y++ {
-			for x := b.Min.X; x < b.Max.X; x++ {
-				if c := m.RGBAAt(x, y); c.R > c.A || c.G > c.A || c.B > c.A {
-					return fmt.Errorf("invalid color.RGBA at (%d, %d): %v", x, y, c)
-				}
-			}
-		}
-		return nil
-	}
-
-	src := image.NewRGBA(image.Rect(0, 0, 16, 16))
-	for y := 0; y < 16; y++ {
-		for x := 0; x < 16; x++ {
-			a := y * 0x11
-			src.Set(x, y, color.RGBA{
-				R: uint8(x * 0x11 * a / 0xff),
-				A: uint8(a),
-			})
-		}
-	}
-	if err := check(src); err != nil {
-		t.Fatalf("src image: %v", err)
-	}
-
-	dst := image.NewRGBA(image.Rect(0, 0, 32, 32))
-	CatmullRom.Scale(dst, dst.Bounds(), src, src.Bounds(), Over, nil)
-	if err := check(dst); err != nil {
-		t.Fatalf("dst image: %v", err)
-	}
-}
-
-func fillPix(r *rand.Rand, pixs ...[]byte) {
-	for _, pix := range pixs {
-		for i := range pix {
-			pix[i] = uint8(r.Intn(256))
-		}
-	}
-}
-
-func TestInterpClipCommute(t *testing.T) {
-	src := image.NewNRGBA(image.Rect(0, 0, 20, 20))
-	fillPix(rand.New(rand.NewSource(0)), src.Pix)
-
-	outer := image.Rect(1, 1, 8, 5)
-	inner := image.Rect(2, 3, 6, 5)
-	qs := []Interpolator{
-		NearestNeighbor,
-		ApproxBiLinear,
-		CatmullRom,
-	}
-	for _, transform := range []bool{false, true} {
-		for _, q := range qs {
-			dst0 := image.NewRGBA(image.Rect(1, 1, 10, 10))
-			dst1 := image.NewRGBA(image.Rect(1, 1, 10, 10))
-			for i := range dst0.Pix {
-				dst0.Pix[i] = uint8(i / 4)
-				dst1.Pix[i] = uint8(i / 4)
-			}
-
-			var interp func(dst *image.RGBA)
-			if transform {
-				interp = func(dst *image.RGBA) {
-					q.Transform(dst, transformMatrix(3.75, 2, 1), src, src.Bounds(), Over, nil)
-				}
-			} else {
-				interp = func(dst *image.RGBA) {
-					q.Scale(dst, outer, src, src.Bounds(), Over, nil)
-				}
-			}
-
-			// Interpolate then clip.
-			interp(dst0)
-			dst0 = dst0.SubImage(inner).(*image.RGBA)
-
-			// Clip then interpolate.
-			dst1 = dst1.SubImage(inner).(*image.RGBA)
-			interp(dst1)
-
-		loop:
-			for y := inner.Min.Y; y < inner.Max.Y; y++ {
-				for x := inner.Min.X; x < inner.Max.X; x++ {
-					if c0, c1 := dst0.RGBAAt(x, y), dst1.RGBAAt(x, y); c0 != c1 {
-						t.Errorf("q=%T: at (%d, %d): c0=%v, c1=%v", q, x, y, c0, c1)
-						break loop
-					}
-				}
-			}
-		}
-	}
-}
-
-// translatedImage is an image m translated by t.
-type translatedImage struct {
-	m image.Image
-	t image.Point
-}
-
-func (t *translatedImage) At(x, y int) color.Color { return t.m.At(x-t.t.X, y-t.t.Y) }
-func (t *translatedImage) Bounds() image.Rectangle { return t.m.Bounds().Add(t.t) }
-func (t *translatedImage) ColorModel() color.Model { return t.m.ColorModel() }
-
-// TestSrcTranslationInvariance tests that Scale and Transform are invariant
-// under src translations. Specifically, when some source pixels are not in the
-// bottom-right quadrant of src coordinate space, we consistently round down,
-// not round towards zero.
-func TestSrcTranslationInvariance(t *testing.T) {
-	f, err := os.Open("../testdata/testpattern.png")
-	if err != nil {
-		t.Fatalf("Open: %v", err)
-	}
-	defer f.Close()
-	src, _, err := image.Decode(f)
-	if err != nil {
-		t.Fatalf("Decode: %v", err)
-	}
-	sr := image.Rect(2, 3, 16, 12)
-	if !sr.In(src.Bounds()) {
-		t.Fatalf("src bounds too small: got %v", src.Bounds())
-	}
-	qs := []Interpolator{
-		NearestNeighbor,
-		ApproxBiLinear,
-		CatmullRom,
-	}
-	deltas := []image.Point{
-		{+0, +0},
-		{+0, +5},
-		{+0, -5},
-		{+5, +0},
-		{-5, +0},
-		{+8, +8},
-		{+8, -8},
-		{-8, +8},
-		{-8, -8},
-	}
-	m00 := transformMatrix(3.75, 0, 0)
-
-	for _, transform := range []bool{false, true} {
-		for _, q := range qs {
-			want := image.NewRGBA(image.Rect(0, 0, 20, 20))
-			if transform {
-				q.Transform(want, m00, src, sr, Over, nil)
-			} else {
-				q.Scale(want, want.Bounds(), src, sr, Over, nil)
-			}
-			for _, delta := range deltas {
-				tsrc := &translatedImage{src, delta}
-				got := image.NewRGBA(image.Rect(0, 0, 20, 20))
-				if transform {
-					m := matMul(&m00, &f64.Aff3{
-						1, 0, -float64(delta.X),
-						0, 1, -float64(delta.Y),
-					})
-					q.Transform(got, m, tsrc, sr.Add(delta), Over, nil)
-				} else {
-					q.Scale(got, got.Bounds(), tsrc, sr.Add(delta), Over, nil)
-				}
-				if !bytes.Equal(got.Pix, want.Pix) {
-					t.Errorf("pix differ for delta=%v, transform=%t, q=%T", delta, transform, q)
-				}
-			}
-		}
-	}
-}
-
-func TestSrcMask(t *testing.T) {
-	srcMask := image.NewRGBA(image.Rect(0, 0, 23, 1))
-	srcMask.SetRGBA(19, 0, color.RGBA{0x00, 0x00, 0x00, 0x7f})
-	srcMask.SetRGBA(20, 0, color.RGBA{0x00, 0x00, 0x00, 0xff})
-	srcMask.SetRGBA(21, 0, color.RGBA{0x00, 0x00, 0x00, 0x3f})
-	srcMask.SetRGBA(22, 0, color.RGBA{0x00, 0x00, 0x00, 0x00})
-	red := image.NewUniform(color.RGBA{0xff, 0x00, 0x00, 0xff})
-	blue := image.NewUniform(color.RGBA{0x00, 0x00, 0xff, 0xff})
-	dst := image.NewRGBA(image.Rect(0, 0, 6, 1))
-	Copy(dst, image.Point{}, blue, dst.Bounds(), Src, nil)
-	NearestNeighbor.Scale(dst, dst.Bounds(), red, image.Rect(0, 0, 3, 1), Over, &Options{
-		SrcMask:  srcMask,
-		SrcMaskP: image.Point{20, 0},
-	})
-	got := [6]color.RGBA{
-		dst.RGBAAt(0, 0),
-		dst.RGBAAt(1, 0),
-		dst.RGBAAt(2, 0),
-		dst.RGBAAt(3, 0),
-		dst.RGBAAt(4, 0),
-		dst.RGBAAt(5, 0),
-	}
-	want := [6]color.RGBA{
-		{0xff, 0x00, 0x00, 0xff},
-		{0xff, 0x00, 0x00, 0xff},
-		{0x3f, 0x00, 0xc0, 0xff},
-		{0x3f, 0x00, 0xc0, 0xff},
-		{0x00, 0x00, 0xff, 0xff},
-		{0x00, 0x00, 0xff, 0xff},
-	}
-	if got != want {
-		t.Errorf("\ngot  %v\nwant %v", got, want)
-	}
-}
-
-func TestDstMask(t *testing.T) {
-	dstMask := image.NewRGBA(image.Rect(0, 0, 23, 1))
-	dstMask.SetRGBA(19, 0, color.RGBA{0x00, 0x00, 0x00, 0x7f})
-	dstMask.SetRGBA(20, 0, color.RGBA{0x00, 0x00, 0x00, 0xff})
-	dstMask.SetRGBA(21, 0, color.RGBA{0x00, 0x00, 0x00, 0x3f})
-	dstMask.SetRGBA(22, 0, color.RGBA{0x00, 0x00, 0x00, 0x00})
-	red := image.NewRGBA(image.Rect(0, 0, 1, 1))
-	red.SetRGBA(0, 0, color.RGBA{0xff, 0x00, 0x00, 0xff})
-	blue := image.NewUniform(color.RGBA{0x00, 0x00, 0xff, 0xff})
-	qs := []Interpolator{
-		NearestNeighbor,
-		ApproxBiLinear,
-		CatmullRom,
-	}
-	for _, q := range qs {
-		dst := image.NewRGBA(image.Rect(0, 0, 3, 1))
-		Copy(dst, image.Point{}, blue, dst.Bounds(), Src, nil)
-		q.Scale(dst, dst.Bounds(), red, red.Bounds(), Over, &Options{
-			DstMask:  dstMask,
-			DstMaskP: image.Point{20, 0},
-		})
-		got := [3]color.RGBA{
-			dst.RGBAAt(0, 0),
-			dst.RGBAAt(1, 0),
-			dst.RGBAAt(2, 0),
-		}
-		want := [3]color.RGBA{
-			{0xff, 0x00, 0x00, 0xff},
-			{0x3f, 0x00, 0xc0, 0xff},
-			{0x00, 0x00, 0xff, 0xff},
-		}
-		if got != want {
-			t.Errorf("q=%T:\ngot  %v\nwant %v", q, got, want)
-		}
-	}
-}
-
-func TestRectDstMask(t *testing.T) {
-	f, err := os.Open("../testdata/testpattern.png")
-	if err != nil {
-		t.Fatalf("Open: %v", err)
-	}
-	defer f.Close()
-	src, _, err := image.Decode(f)
-	if err != nil {
-		t.Fatalf("Decode: %v", err)
-	}
-	m00 := transformMatrix(1, 0, 0)
-
-	bounds := image.Rect(0, 0, 50, 50)
-	dstOutside := image.NewRGBA(bounds)
-	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
-		for x := bounds.Min.X; x < bounds.Max.X; x++ {
-			dstOutside.SetRGBA(x, y, color.RGBA{uint8(5 * x), uint8(5 * y), 0x00, 0xff})
-		}
-	}
-
-	mk := func(q Transformer, dstMask image.Image, dstMaskP image.Point) *image.RGBA {
-		m := image.NewRGBA(bounds)
-		Copy(m, bounds.Min, dstOutside, bounds, Src, nil)
-		q.Transform(m, m00, src, src.Bounds(), Over, &Options{
-			DstMask:  dstMask,
-			DstMaskP: dstMaskP,
-		})
-		return m
-	}
-
-	qs := []Interpolator{
-		NearestNeighbor,
-		ApproxBiLinear,
-		CatmullRom,
-	}
-	dstMaskPs := []image.Point{
-		{0, 0},
-		{5, 7},
-		{-3, 0},
-	}
-	rect := image.Rect(10, 10, 30, 40)
-	for _, q := range qs {
-		for _, dstMaskP := range dstMaskPs {
-			dstInside := mk(q, nil, image.Point{})
-			for _, wrap := range []bool{false, true} {
-				// TODO: replace "rectImage(rect)" with "rect" once Go 1.5 is
-				// released, where an image.Rectangle implements image.Image.
-				dstMask := image.Image(rectImage(rect))
-				if wrap {
-					dstMask = srcWrapper{dstMask}
-				}
-				dst := mk(q, dstMask, dstMaskP)
-
-				nError := 0
-			loop:
-				for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
-					for x := bounds.Min.X; x < bounds.Max.X; x++ {
-						which := dstOutside
-						if (image.Point{x, y}).Add(dstMaskP).In(rect) {
-							which = dstInside
-						}
-						if got, want := dst.RGBAAt(x, y), which.RGBAAt(x, y); got != want {
-							if nError == 10 {
-								t.Errorf("q=%T dmp=%v wrap=%v: ...and more errors", q, dstMaskP, wrap)
-								break loop
-							}
-							nError++
-							t.Errorf("q=%T dmp=%v wrap=%v: x=%3d y=%3d: got %v, want %v",
-								q, dstMaskP, wrap, x, y, got, want)
-						}
-					}
-				}
-			}
-		}
-	}
-}
-
-func TestDstMaskSameSizeCopy(t *testing.T) {
-	bounds := image.Rect(0, 0, 42, 42)
-	src := image.Opaque
-	dst := image.NewRGBA(bounds)
-	mask := image.NewRGBA(bounds)
-
-	Copy(dst, image.ZP, src, bounds, Src, &Options{
-		DstMask: mask,
-	})
-}
-
-// TODO: delete this wrapper type once Go 1.5 is released, where an
-// image.Rectangle implements image.Image.
-type rectImage image.Rectangle
-
-func (r rectImage) ColorModel() color.Model { return color.Alpha16Model }
-func (r rectImage) Bounds() image.Rectangle { return image.Rectangle(r) }
-func (r rectImage) At(x, y int) color.Color {
-	if (image.Point{x, y}).In(image.Rectangle(r)) {
-		return color.Opaque
-	}
-	return color.Transparent
-}
-
-// The fooWrapper types wrap the dst or src image to avoid triggering the
-// type-specific fast path implementations.
-type (
-	dstWrapper struct{ Image }
-	srcWrapper struct{ image.Image }
-)
-
-func srcGray(boundsHint image.Rectangle) (image.Image, error) {
-	m := image.NewGray(boundsHint)
-	fillPix(rand.New(rand.NewSource(0)), m.Pix)
-	return m, nil
-}
-
-func srcNRGBA(boundsHint image.Rectangle) (image.Image, error) {
-	m := image.NewNRGBA(boundsHint)
-	fillPix(rand.New(rand.NewSource(1)), m.Pix)
-	return m, nil
-}
-
-func srcRGBA(boundsHint image.Rectangle) (image.Image, error) {
-	m := image.NewRGBA(boundsHint)
-	fillPix(rand.New(rand.NewSource(2)), m.Pix)
-	// RGBA is alpha-premultiplied, so the R, G and B values should
-	// be <= the A values.
-	for i := 0; i < len(m.Pix); i += 4 {
-		m.Pix[i+0] = uint8(uint32(m.Pix[i+0]) * uint32(m.Pix[i+3]) / 0xff)
-		m.Pix[i+1] = uint8(uint32(m.Pix[i+1]) * uint32(m.Pix[i+3]) / 0xff)
-		m.Pix[i+2] = uint8(uint32(m.Pix[i+2]) * uint32(m.Pix[i+3]) / 0xff)
-	}
-	return m, nil
-}
-
-func srcUnif(boundsHint image.Rectangle) (image.Image, error) {
-	return image.NewUniform(color.RGBA64{0x1234, 0x5555, 0x9181, 0xbeef}), nil
-}
-
-func srcYCbCr(boundsHint image.Rectangle) (image.Image, error) {
-	m := image.NewYCbCr(boundsHint, image.YCbCrSubsampleRatio420)
-	fillPix(rand.New(rand.NewSource(3)), m.Y, m.Cb, m.Cr)
-	return m, nil
-}
-
-func srcLarge(boundsHint image.Rectangle) (image.Image, error) {
-	// 3072 x 2304 is over 7 million pixels at 4:3, comparable to a
-	// 2015 smart-phone camera's output.
-	return srcYCbCr(image.Rect(0, 0, 3072, 2304))
-}
-
-func srcTux(boundsHint image.Rectangle) (image.Image, error) {
-	// tux.png is a 386 x 395 image.
-	f, err := os.Open("../testdata/tux.png")
-	if err != nil {
-		return nil, fmt.Errorf("Open: %v", err)
-	}
-	defer f.Close()
-	src, err := png.Decode(f)
-	if err != nil {
-		return nil, fmt.Errorf("Decode: %v", err)
-	}
-	return src, nil
-}
-
-func benchScale(b *testing.B, w int, h int, op Op, srcf func(image.Rectangle) (image.Image, error), q Interpolator) {
-	dst := image.NewRGBA(image.Rect(0, 0, w, h))
-	src, err := srcf(image.Rect(0, 0, 1024, 768))
-	if err != nil {
-		b.Fatal(err)
-	}
-	dr, sr := dst.Bounds(), src.Bounds()
-	scaler := Scaler(q)
-	if n, ok := q.(interface {
-		NewScaler(int, int, int, int) Scaler
-	}); ok {
-		scaler = n.NewScaler(dr.Dx(), dr.Dy(), sr.Dx(), sr.Dy())
-	}
-
-	b.ReportAllocs()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		scaler.Scale(dst, dr, src, sr, op, nil)
-	}
-}
-
-func benchTform(b *testing.B, w int, h int, op Op, srcf func(image.Rectangle) (image.Image, error), q Interpolator) {
-	dst := image.NewRGBA(image.Rect(0, 0, w, h))
-	src, err := srcf(image.Rect(0, 0, 1024, 768))
-	if err != nil {
-		b.Fatal(err)
-	}
-	sr := src.Bounds()
-	m := transformMatrix(3.75, 40, 10)
-
-	b.ReportAllocs()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		q.Transform(dst, m, src, sr, op, nil)
-	}
-}
-
-func BenchmarkScaleNNLargeDown(b *testing.B) { benchScale(b, 200, 150, Src, srcLarge, NearestNeighbor) }
-func BenchmarkScaleABLargeDown(b *testing.B) { benchScale(b, 200, 150, Src, srcLarge, ApproxBiLinear) }
-func BenchmarkScaleBLLargeDown(b *testing.B) { benchScale(b, 200, 150, Src, srcLarge, BiLinear) }
-func BenchmarkScaleCRLargeDown(b *testing.B) { benchScale(b, 200, 150, Src, srcLarge, CatmullRom) }
-
-func BenchmarkScaleNNDown(b *testing.B) { benchScale(b, 120, 80, Src, srcTux, NearestNeighbor) }
-func BenchmarkScaleABDown(b *testing.B) { benchScale(b, 120, 80, Src, srcTux, ApproxBiLinear) }
-func BenchmarkScaleBLDown(b *testing.B) { benchScale(b, 120, 80, Src, srcTux, BiLinear) }
-func BenchmarkScaleCRDown(b *testing.B) { benchScale(b, 120, 80, Src, srcTux, CatmullRom) }
-
-func BenchmarkScaleNNUp(b *testing.B) { benchScale(b, 800, 600, Src, srcTux, NearestNeighbor) }
-func BenchmarkScaleABUp(b *testing.B) { benchScale(b, 800, 600, Src, srcTux, ApproxBiLinear) }
-func BenchmarkScaleBLUp(b *testing.B) { benchScale(b, 800, 600, Src, srcTux, BiLinear) }
-func BenchmarkScaleCRUp(b *testing.B) { benchScale(b, 800, 600, Src, srcTux, CatmullRom) }
-
-func BenchmarkScaleNNSrcRGBA(b *testing.B) { benchScale(b, 200, 150, Src, srcRGBA, NearestNeighbor) }
-func BenchmarkScaleNNSrcUnif(b *testing.B) { benchScale(b, 200, 150, Src, srcUnif, NearestNeighbor) }
-
-func BenchmarkScaleNNOverRGBA(b *testing.B) { benchScale(b, 200, 150, Over, srcRGBA, NearestNeighbor) }
-func BenchmarkScaleNNOverUnif(b *testing.B) { benchScale(b, 200, 150, Over, srcUnif, NearestNeighbor) }
-
-func BenchmarkTformNNSrcRGBA(b *testing.B) { benchTform(b, 200, 150, Src, srcRGBA, NearestNeighbor) }
-func BenchmarkTformNNSrcUnif(b *testing.B) { benchTform(b, 200, 150, Src, srcUnif, NearestNeighbor) }
-
-func BenchmarkTformNNOverRGBA(b *testing.B) { benchTform(b, 200, 150, Over, srcRGBA, NearestNeighbor) }
-func BenchmarkTformNNOverUnif(b *testing.B) { benchTform(b, 200, 150, Over, srcUnif, NearestNeighbor) }
-
-func BenchmarkScaleABSrcGray(b *testing.B)  { benchScale(b, 200, 150, Src, srcGray, ApproxBiLinear) }
-func BenchmarkScaleABSrcNRGBA(b *testing.B) { benchScale(b, 200, 150, Src, srcNRGBA, ApproxBiLinear) }
-func BenchmarkScaleABSrcRGBA(b *testing.B)  { benchScale(b, 200, 150, Src, srcRGBA, ApproxBiLinear) }
-func BenchmarkScaleABSrcYCbCr(b *testing.B) { benchScale(b, 200, 150, Src, srcYCbCr, ApproxBiLinear) }
-
-func BenchmarkScaleABOverGray(b *testing.B)  { benchScale(b, 200, 150, Over, srcGray, ApproxBiLinear) }
-func BenchmarkScaleABOverNRGBA(b *testing.B) { benchScale(b, 200, 150, Over, srcNRGBA, ApproxBiLinear) }
-func BenchmarkScaleABOverRGBA(b *testing.B)  { benchScale(b, 200, 150, Over, srcRGBA, ApproxBiLinear) }
-func BenchmarkScaleABOverYCbCr(b *testing.B) { benchScale(b, 200, 150, Over, srcYCbCr, ApproxBiLinear) }
-
-func BenchmarkTformABSrcGray(b *testing.B)  { benchTform(b, 200, 150, Src, srcGray, ApproxBiLinear) }
-func BenchmarkTformABSrcNRGBA(b *testing.B) { benchTform(b, 200, 150, Src, srcNRGBA, ApproxBiLinear) }
-func BenchmarkTformABSrcRGBA(b *testing.B)  { benchTform(b, 200, 150, Src, srcRGBA, ApproxBiLinear) }
-func BenchmarkTformABSrcYCbCr(b *testing.B) { benchTform(b, 200, 150, Src, srcYCbCr, ApproxBiLinear) }
-
-func BenchmarkTformABOverGray(b *testing.B)  { benchTform(b, 200, 150, Over, srcGray, ApproxBiLinear) }
-func BenchmarkTformABOverNRGBA(b *testing.B) { benchTform(b, 200, 150, Over, srcNRGBA, ApproxBiLinear) }
-func BenchmarkTformABOverRGBA(b *testing.B)  { benchTform(b, 200, 150, Over, srcRGBA, ApproxBiLinear) }
-func BenchmarkTformABOverYCbCr(b *testing.B) { benchTform(b, 200, 150, Over, srcYCbCr, ApproxBiLinear) }
-
-func BenchmarkScaleCRSrcGray(b *testing.B)  { benchScale(b, 200, 150, Src, srcGray, CatmullRom) }
-func BenchmarkScaleCRSrcNRGBA(b *testing.B) { benchScale(b, 200, 150, Src, srcNRGBA, CatmullRom) }
-func BenchmarkScaleCRSrcRGBA(b *testing.B)  { benchScale(b, 200, 150, Src, srcRGBA, CatmullRom) }
-func BenchmarkScaleCRSrcYCbCr(b *testing.B) { benchScale(b, 200, 150, Src, srcYCbCr, CatmullRom) }
-
-func BenchmarkScaleCROverGray(b *testing.B)  { benchScale(b, 200, 150, Over, srcGray, CatmullRom) }
-func BenchmarkScaleCROverNRGBA(b *testing.B) { benchScale(b, 200, 150, Over, srcNRGBA, CatmullRom) }
-func BenchmarkScaleCROverRGBA(b *testing.B)  { benchScale(b, 200, 150, Over, srcRGBA, CatmullRom) }
-func BenchmarkScaleCROverYCbCr(b *testing.B) { benchScale(b, 200, 150, Over, srcYCbCr, CatmullRom) }
-
-func BenchmarkTformCRSrcGray(b *testing.B)  { benchTform(b, 200, 150, Src, srcGray, CatmullRom) }
-func BenchmarkTformCRSrcNRGBA(b *testing.B) { benchTform(b, 200, 150, Src, srcNRGBA, CatmullRom) }
-func BenchmarkTformCRSrcRGBA(b *testing.B)  { benchTform(b, 200, 150, Src, srcRGBA, CatmullRom) }
-func BenchmarkTformCRSrcYCbCr(b *testing.B) { benchTform(b, 200, 150, Src, srcYCbCr, CatmullRom) }
-
-func BenchmarkTformCROverGray(b *testing.B)  { benchTform(b, 200, 150, Over, srcGray, CatmullRom) }
-func BenchmarkTformCROverNRGBA(b *testing.B) { benchTform(b, 200, 150, Over, srcNRGBA, CatmullRom) }
-func BenchmarkTformCROverRGBA(b *testing.B)  { benchTform(b, 200, 150, Over, srcRGBA, CatmullRom) }
-func BenchmarkTformCROverYCbCr(b *testing.B) { benchTform(b, 200, 150, Over, srcYCbCr, CatmullRom) }

vendor/golang.org/x/image/draw/stdlib_test.go

@@ -1,96 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build go1.9
-
-package draw
-
-// This file contains tests that depend on the exact behavior of the
-// image/color package in the standard library. The color conversion formula
-// from YCbCr to RGBA changed between Go 1.4 and Go 1.5, and between Go 1.8 and
-// Go 1.9, so this file's tests are only enabled for Go 1.9 and above.
-
-import (
-	"bytes"
-	"image"
-	"image/color"
-	"testing"
-)
-
-// TestFastPaths tests that the fast path implementations produce identical
-// results to the generic implementation.
-func TestFastPaths(t *testing.T) {
-	drs := []image.Rectangle{
-		image.Rect(0, 0, 10, 10),   // The dst bounds.
-		image.Rect(3, 4, 8, 6),     // A strict subset of the dst bounds.
-		image.Rect(-3, -5, 2, 4),   // Partial out-of-bounds #0.
-		image.Rect(4, -2, 6, 12),   // Partial out-of-bounds #1.
-		image.Rect(12, 14, 23, 45), // Complete out-of-bounds.
-		image.Rect(5, 5, 5, 5),     // Empty.
-	}
-	srs := []image.Rectangle{
-		image.Rect(0, 0, 12, 9),    // The src bounds.
-		image.Rect(2, 2, 10, 8),    // A strict subset of the src bounds.
-		image.Rect(10, 5, 20, 20),  // Partial out-of-bounds #0.
-		image.Rect(-40, 0, 40, 8),  // Partial out-of-bounds #1.
-		image.Rect(-8, -8, -4, -4), // Complete out-of-bounds.
-		image.Rect(5, 5, 5, 5),     // Empty.
-	}
-	srcfs := []func(image.Rectangle) (image.Image, error){
-		srcGray,
-		srcNRGBA,
-		srcRGBA,
-		srcUnif,
-		srcYCbCr,
-	}
-	var srcs []image.Image
-	for _, srcf := range srcfs {
-		src, err := srcf(srs[0])
-		if err != nil {
-			t.Fatal(err)
-		}
-		srcs = append(srcs, src)
-	}
-	qs := []Interpolator{
-		NearestNeighbor,
-		ApproxBiLinear,
-		CatmullRom,
-	}
-	ops := []Op{
-		Over,
-		Src,
-	}
-	blue := image.NewUniform(color.RGBA{0x11, 0x22, 0x44, 0x7f})
-
-	for _, dr := range drs {
-		for _, src := range srcs {
-			for _, sr := range srs {
-				for _, transform := range []bool{false, true} {
-					for _, q := range qs {
-						for _, op := range ops {
-							dst0 := image.NewRGBA(drs[0])
-							dst1 := image.NewRGBA(drs[0])
-							Draw(dst0, dst0.Bounds(), blue, image.Point{}, Src)
-							Draw(dstWrapper{dst1}, dst1.Bounds(), srcWrapper{blue}, image.Point{}, Src)
-
-							if transform {
-								m := transformMatrix(3.75, 2, 1)
-								q.Transform(dst0, m, src, sr, op, nil)
-								q.Transform(dstWrapper{dst1}, m, srcWrapper{src}, sr, op, nil)
-							} else {
-								q.Scale(dst0, dr, src, sr, op, nil)
-								q.Scale(dstWrapper{dst1}, dr, srcWrapper{src}, sr, op, nil)
-							}
-
-							if !bytes.Equal(dst0.Pix, dst1.Pix) {
-								t.Errorf("pix differ for dr=%v, src=%T, sr=%v, transform=%t, q=%T",
-									dr, src, sr, transform, q)
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-}

vendor/golang.org/x/image/example/font/main.go

@@ -1,106 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build example
-//
-// This build tag means that "go install golang.org/x/image/..." doesn't
-// install this example program. Use "go run main.go" to run it or "go install
-// -tags=example" to install it.
-
-// Font is a basic example of using fonts.
-package main
-
-import (
-	"flag"
-	"image"
-	"image/color"
-	"image/draw"
-	"image/png"
-	"io/ioutil"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"golang.org/x/image/font"
-	"golang.org/x/image/font/plan9font"
-	"golang.org/x/image/math/fixed"
-)
-
-var (
-	fontFlag = flag.String("font", "",
-		`filename of the Plan 9 font or subfont file, such as "lucsans/unicode.8.font" or "lucsans/lsr.14"`)
-	firstRuneFlag = flag.Int("firstrune", 0, "the Unicode code point of the first rune in the subfont file")
-)
-
-func pt(p fixed.Point26_6) image.Point {
-	return image.Point{
-		X: int(p.X+32) >> 6,
-		Y: int(p.Y+32) >> 6,
-	}
-}
-
-func main() {
-	flag.Parse()
-
-	// TODO: mmap the files.
-	if *fontFlag == "" {
-		flag.Usage()
-		log.Fatal("no font specified")
-	}
-	var face font.Face
-	if strings.HasSuffix(*fontFlag, ".font") {
-		fontData, err := ioutil.ReadFile(*fontFlag)
-		if err != nil {
-			log.Fatal(err)
-		}
-		dir := filepath.Dir(*fontFlag)
-		face, err = plan9font.ParseFont(fontData, func(name string) ([]byte, error) {
-			return ioutil.ReadFile(filepath.Join(dir, filepath.FromSlash(name)))
-		})
-		if err != nil {
-			log.Fatal(err)
-		}
-	} else {
-		fontData, err := ioutil.ReadFile(*fontFlag)
-		if err != nil {
-			log.Fatal(err)
-		}
-		face, err = plan9font.ParseSubfont(fontData, rune(*firstRuneFlag))
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-
-	dst := image.NewRGBA(image.Rect(0, 0, 800, 300))
-	draw.Draw(dst, dst.Bounds(), image.Black, image.Point{}, draw.Src)
-
-	d := &font.Drawer{
-		Dst:  dst,
-		Src:  image.White,
-		Face: face,
-	}
-	ss := []string{
-		"The quick brown fox jumps over the lazy dog.",
-		"Hello, 世界.",
-		"U+FFFD is \ufffd.",
-	}
-	for i, s := range ss {
-		d.Dot = fixed.P(20, 100*i+80)
-		dot0 := pt(d.Dot)
-		d.DrawString(s)
-		dot1 := pt(d.Dot)
-		dst.SetRGBA(dot0.X, dot0.Y, color.RGBA{0xff, 0x00, 0x00, 0xff})
-		dst.SetRGBA(dot1.X, dot1.Y, color.RGBA{0x00, 0x00, 0xff, 0xff})
-	}
-
-	out, err := os.Create("out.png")
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer out.Close()
-	if err := png.Encode(out, dst); err != nil {
-		log.Fatal(err)
-	}
-}

vendor/golang.org/x/image/font/basicfont/basicfont.go

@@ -1,126 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:generate go run gen.go
-
-// Package basicfont provides fixed-size font faces.
-package basicfont // import "golang.org/x/image/font/basicfont"
-
-import (
-	"image"
-
-	"golang.org/x/image/font"
-	"golang.org/x/image/math/fixed"
-)
-
-// Range maps a contiguous range of runes to vertically adjacent sub-images of
-// a Face's Mask image. The rune range is inclusive on the low end and
-// exclusive on the high end.
-//
-// If Low <= r && r < High, then the rune r is mapped to the sub-image of
-// Face.Mask whose bounds are image.Rect(0, y*h, Face.Width, (y+1)*h),
-// where y = (int(r-Low) + Offset) and h = (Face.Ascent + Face.Descent).
-type Range struct {
-	Low, High rune
-	Offset    int
-}
-
-// Face7x13 is a Face derived from the public domain X11 misc-fixed font files.
-//
-// At the moment, it holds the printable characters in ASCII starting with
-// space, and the Unicode replacement character U+FFFD.
-//
-// Its data is entirely self-contained and does not require loading from
-// separate files.
-var Face7x13 = &Face{
-	Advance: 7,
-	Width:   6,
-	Height:  13,
-	Ascent:  11,
-	Descent: 2,
-	Mask:    mask7x13,
-	Ranges: []Range{
-		{'\u0020', '\u007f', 0},
-		{'\ufffd', '\ufffe', 95},
-	},
-}
-
-// Face is a basic font face whose glyphs all have the same metrics.
-//
-// It is safe to use concurrently.
-type Face struct {
-	// Advance is the glyph advance, in pixels.
-	Advance int
-	// Width is the glyph width, in pixels.
-	Width int
-	// Height is the inter-line height, in pixels.
-	Height int
-	// Ascent is the glyph ascent, in pixels.
-	Ascent int
-	// Descent is the glyph descent, in pixels.
-	Descent int
-	// Left is the left side bearing, in pixels. A positive value means that
-	// all of a glyph is to the right of the dot.
-	Left int
-
-	// Mask contains all of the glyph masks. Its width is typically the Face's
-	// Width, and its height a multiple of the Face's Height.
-	Mask image.Image
-	// Ranges map runes to sub-images of Mask. The rune ranges must not
-	// overlap, and must be in increasing rune order.
-	Ranges []Range
-}
-
-func (f *Face) Close() error                   { return nil }
-func (f *Face) Kern(r0, r1 rune) fixed.Int26_6 { return 0 }
-
-func (f *Face) Metrics() font.Metrics {
-	return font.Metrics{
-		Height:  fixed.I(f.Height),
-		Ascent:  fixed.I(f.Ascent),
-		Descent: fixed.I(f.Descent),
-	}
-}
-
-func (f *Face) Glyph(dot fixed.Point26_6, r rune) (
-	dr image.Rectangle, mask image.Image, maskp image.Point, advance fixed.Int26_6, ok bool) {
-
-loop:
-	for _, rr := range [2]rune{r, '\ufffd'} {
-		for _, rng := range f.Ranges {
-			if rr < rng.Low || rng.High <= rr {
-				continue
-			}
-			maskp.Y = (int(rr-rng.Low) + rng.Offset) * (f.Ascent + f.Descent)
-			ok = true
-			break loop
-		}
-	}
-	if !ok {
-		return image.Rectangle{}, nil, image.Point{}, 0, false
-	}
-
-	x := int(dot.X+32)>>6 + f.Left
-	y := int(dot.Y+32) >> 6
-	dr = image.Rectangle{
-		Min: image.Point{
-			X: x,
-			Y: y - f.Ascent,
-		},
-		Max: image.Point{
-			X: x + f.Width,
-			Y: y + f.Descent,
-		},
-	}
-
-	return dr, f.Mask, maskp, fixed.I(f.Advance), true
-}
-
-func (f *Face) GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool) {
-	return fixed.R(0, -f.Ascent, f.Width, +f.Descent), fixed.I(f.Advance), true
-}
-
-func (f *Face) GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool) {
-	return fixed.I(f.Advance), true
-}

vendor/golang.org/x/image/font/basicfont/gen.go

@@ -1,115 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// This program generates data.go.
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"go/format"
-	"image"
-	"image/draw"
-	"io/ioutil"
-	"log"
-	"path"
-	"path/filepath"
-
-	"golang.org/x/image/font"
-	"golang.org/x/image/font/plan9font"
-	"golang.org/x/image/math/fixed"
-)
-
-func main() {
-	// nGlyphs is the number of glyphs to generate: 95 characters in the range
-	// [0x20, 0x7e], plus the replacement character.
-	const nGlyphs = 95 + 1
-	// The particular font (unicode.7x13.font) leaves the right-most column
-	// empty in its ASCII glyphs. We don't have to include that column in the
-	// generated glyphs, so we subtract one off the effective width.
-	const width, height, ascent = 7 - 1, 13, 11
-
-	readFile := func(name string) ([]byte, error) {
-		return ioutil.ReadFile(filepath.FromSlash(path.Join("../testdata/fixed", name)))
-	}
-	fontData, err := readFile("unicode.7x13.font")
-	if err != nil {
-		log.Fatalf("readFile: %v", err)
-	}
-	face, err := plan9font.ParseFont(fontData, readFile)
-	if err != nil {
-		log.Fatalf("plan9font.ParseFont: %v", err)
-	}
-
-	dst := image.NewRGBA(image.Rect(0, 0, width, nGlyphs*height))
-	draw.Draw(dst, dst.Bounds(), image.Black, image.Point{}, draw.Src)
-	d := &font.Drawer{
-		Dst:  dst,
-		Src:  image.White,
-		Face: face,
-	}
-	for i := 0; i < nGlyphs; i++ {
-		r := '\ufffd'
-		if i < nGlyphs-1 {
-			r = 0x20 + rune(i)
-		}
-		d.Dot = fixed.P(0, height*i+ascent)
-		d.DrawString(string(r))
-	}
-
-	w := bytes.NewBuffer(nil)
-	w.WriteString(preamble)
-	fmt.Fprintf(w, "// mask7x13 contains %d %d×%d glyphs in %d Pix bytes.\n", nGlyphs, width, height, nGlyphs*width*height)
-	fmt.Fprintf(w, "var mask7x13 = &image.Alpha{\n")
-	fmt.Fprintf(w, "  Stride: %d,\n", width)
-	fmt.Fprintf(w, "  Rect: image.Rectangle{Max: image.Point{%d, %d*%d}},\n", width, nGlyphs, height)
-	fmt.Fprintf(w, "  Pix: []byte{\n")
-	b := dst.Bounds()
-	for y := b.Min.Y; y < b.Max.Y; y++ {
-		if y%height == 0 {
-			if y != 0 {
-				w.WriteByte('\n')
-			}
-			i := y / height
-			if i < nGlyphs-1 {
-				i += 0x20
-				fmt.Fprintf(w, "// %#2x %q\n", i, rune(i))
-			} else {
-				fmt.Fprintf(w, "// U+FFFD REPLACEMENT CHARACTER\n")
-			}
-		}
-
-		for x := b.Min.X; x < b.Max.X; x++ {
-			if dst.RGBAAt(x, y).R > 0 {
-				w.WriteString("0xff,")
-			} else {
-				w.WriteString("0x00,")
-			}
-		}
-		w.WriteByte('\n')
-	}
-	w.WriteString("},\n}\n")
-
-	fmted, err := format.Source(w.Bytes())
-	if err != nil {
-		log.Fatalf("format.Source: %v", err)
-	}
-	if err := ioutil.WriteFile("data.go", fmted, 0644); err != nil {
-		log.Fatalf("ioutil.WriteFile: %v", err)
-	}
-}
-
-const preamble = `// generated by go generate; DO NOT EDIT.
-
-package basicfont
-
-// This data is derived from files in the font/fixed directory of the Plan 9
-// Port source code (https://github.com/9fans/plan9port) which were originally
-// based on the public domain X11 misc-fixed font files.
-
-import "image"
-
-`

vendor/golang.org/x/image/font/font.go

@@ -1,359 +0,0 @@
-// Copyright 2015 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package font defines an interface for font faces, for drawing text on an
-// image.
-//
-// Other packages provide font face implementations. For example, a truetype
-// package would provide one based on .ttf font files.
-package font // import "golang.org/x/image/font"
-
-import (
-	"image"
-	"image/draw"
-	"io"
-	"unicode/utf8"
-
-	"golang.org/x/image/math/fixed"
-)
-
-// TODO: who is responsible for caches (glyph images, glyph indices, kerns)?
-// The Drawer or the Face?
-
-// Face is a font face. Its glyphs are often derived from a font file, such as
-// "Comic_Sans_MS.ttf", but a face has a specific size, style, weight and
-// hinting. For example, the 12pt and 18pt versions of Comic Sans are two
-// different faces, even if derived from the same font file.
-//
-// A Face is not safe for concurrent use by multiple goroutines, as its methods
-// may re-use implementation-specific caches and mask image buffers.
-//
-// To create a Face, look to other packages that implement specific font file
-// formats.
-type Face interface {
-	io.Closer
-
-	// Glyph returns the draw.DrawMask parameters (dr, mask, maskp) to draw r's
-	// glyph at the sub-pixel destination location dot, and that glyph's
-	// advance width.
-	//
-	// It returns !ok if the face does not contain a glyph for r.
-	//
-	// The contents of the mask image returned by one Glyph call may change
-	// after the next Glyph call. Callers that want to cache the mask must make
-	// a copy.
-	Glyph(dot fixed.Point26_6, r rune) (
-		dr image.Rectangle, mask image.Image, maskp image.Point, advance fixed.Int26_6, ok bool)
-
-	// GlyphBounds returns the bounding box of r's glyph, drawn at a dot equal
-	// to the origin, and that glyph's advance width.
-	//
-	// It returns !ok if the face does not contain a glyph for r.
-	//
-	// The glyph's ascent and descent equal -bounds.Min.Y and +bounds.Max.Y. A
-	// visual depiction of what these metrics are is at
-	// https://developer.apple.com/library/mac/documentation/TextFonts/Conceptual/CocoaTextArchitecture/Art/glyph_metrics_2x.png
-	GlyphBounds(r rune) (bounds fixed.Rectangle26_6, advance fixed.Int26_6, ok bool)
-
-	// GlyphAdvance returns the advance width of r's glyph.
-	//
-	// It returns !ok if the face does not contain a glyph for r.
-	GlyphAdvance(r rune) (advance fixed.Int26_6, ok bool)
-
-	// Kern returns the horizontal adjustment for the kerning pair (r0, r1). A
-	// positive kern means to move the glyphs further apart.
-	Kern(r0, r1 rune) fixed.Int26_6
-
-	// Metrics returns the metrics for this Face.
-	Metrics() Metrics
-
-	// TODO: ColoredGlyph for various emoji?
-	// TODO: Ligatures? Shaping?
-}
-
-// Metrics holds the metrics for a Face. A visual depiction is at
-// https://developer.apple.com/library/mac/documentation/TextFonts/Conceptual/CocoaTextArchitecture/Art/glyph_metrics_2x.png
-type Metrics struct {
-	// Height is the recommended amount of vertical space between two lines of
-	// text.
-	Height fixed.Int26_6
-
-	// Ascent is the distance from the top of a line to its baseline.
-	Ascent fixed.Int26_6
-
-	// Descent is the distance from the bottom of a line to its baseline. The
-	// value is typically positive, even though a descender goes below the
-	// baseline.
-	Descent fixed.Int26_6
-}
-
-// Drawer draws text on a destination image.
-//
-// A Drawer is not safe for concurrent use by multiple goroutines, since its
-// Face is not.
-type Drawer struct {
-	// Dst is the destination image.
-	Dst draw.Image
-	// Src is the source image.
-	Src image.Image
-	// Face provides the glyph mask images.
-	Face Face
-	// Dot is the baseline location to draw the next glyph. The majority of the
-	// affected pixels will be above and to the right of the dot, but some may
-	// be below or to the left. For example, drawing a 'j' in an italic face
-	// may affect pixels below and to the left of the dot.
-	Dot fixed.Point26_6
-
-	// TODO: Clip image.Image?
-	// TODO: SrcP image.Point for Src images other than *image.Uniform? How
-	// does it get updated during DrawString?
-}
-
-// TODO: should DrawString return the last rune drawn, so the next DrawString
-// call can kern beforehand? Or should that be the responsibility of the caller
-// if they really want to do that, since they have to explicitly shift d.Dot
-// anyway? What if ligatures span more than two runes? What if grapheme
-// clusters span multiple runes?
-//
-// TODO: do we assume that the input is in any particular Unicode Normalization
-// Form?
-//
-// TODO: have DrawRunes(s []rune)? DrawRuneReader(io.RuneReader)?? If we take
-// io.RuneReader, we can't assume that we can rewind the stream.
-//
-// TODO: how does this work with line breaking: drawing text up until a
-// vertical line? Should DrawString return the number of runes drawn?
-
-// DrawBytes draws s at the dot and advances the dot's location.
-//
-// It is equivalent to DrawString(string(s)) but may be more efficient.
-func (d *Drawer) DrawBytes(s []byte) {
-	prevC := rune(-1)
-	for len(s) > 0 {
-		c, size := utf8.DecodeRune(s)
-		s = s[size:]
-		if prevC >= 0 {
-			d.Dot.X += d.Face.Kern(prevC, c)
-		}
-		dr, mask, maskp, advance, ok := d.Face.Glyph(d.Dot, c)
-		if !ok {
-			// TODO: is falling back on the U+FFFD glyph the responsibility of
-			// the Drawer or the Face?
-			// TODO: set prevC = '\ufffd'?
-			continue
-		}
-		draw.DrawMask(d.Dst, dr, d.Src, image.Point{}, mask, maskp, draw.Over)
-		d.Dot.X += advance
-		prevC = c
-	}
-}
-
-// DrawString draws s at the dot and advances the dot's location.
-func (d *Drawer) DrawString(s string) {
-	prevC := rune(-1)
-	for _, c := range s {
-		if prevC >= 0 {
-			d.Dot.X += d.Face.Kern(prevC, c)
-		}
-		dr, mask, maskp, advance, ok := d.Face.Glyph(d.Dot, c)
-		if !ok {
-			// TODO: is falling back on the U+FFFD glyph the responsibility of
-			// the Drawer or the Face?
-			// TODO: set prevC = '\ufffd'?
-			continue
-		}
-		draw.DrawMask(d.Dst, dr, d.Src, image.Point{}, mask, maskp, draw.Over)
-		d.Dot.X += advance
-		prevC = c
-	}
-}
-
-// BoundBytes returns the bounding box of s, drawn at the drawer dot, as well as
-// the advance.
-//
-// It is equivalent to BoundBytes(string(s)) but may be more efficient.
-func (d *Drawer) BoundBytes(s []byte) (bounds fixed.Rectangle26_6, advance fixed.Int26_6) {
-	bounds, advance = BoundBytes(d.Face, s)
-	bounds.Min = bounds.Min.Add(d.Dot)
-	bounds.Max = bounds.Max.Add(d.Dot)
-	return
-}
-
-// BoundString returns the bounding box of s, drawn at the drawer dot, as well
-// as the advance.
-func (d *Drawer) BoundString(s string) (bounds fixed.Rectangle26_6, advance fixed.Int26_6) {
-	bounds, advance = BoundString(d.Face, s)
-	bounds.Min = bounds.Min.Add(d.Dot)
-	bounds.Max = bounds.Max.Add(d.Dot)
-	return
-}
-
-// MeasureBytes returns how far dot would advance by drawing s.
-//
-// It is equivalent to MeasureString(string(s)) but may be more efficient.
-func (d *Drawer) MeasureBytes(s []byte) (advance fixed.Int26_6) {
-	return MeasureBytes(d.Face, s)
-}
-
-// MeasureString returns how far dot would advance by drawing s.
-func (d *Drawer) MeasureString(s string) (advance fixed.Int26_6) {
-	return MeasureString(d.Face, s)
-}
-
-// BoundBytes returns the bounding box of s with f, drawn at a dot equal to the
-// origin, as well as the advance.
-//
-// It is equivalent to BoundString(string(s)) but may be more efficient.
-func BoundBytes(f Face, s []byte) (bounds fixed.Rectangle26_6, advance fixed.Int26_6) {
-	prevC := rune(-1)
-	for len(s) > 0 {
-		c, size := utf8.DecodeRune(s)
-		s = s[size:]
-		if prevC >= 0 {
-			advance += f.Kern(prevC, c)
-		}
-		b, a, ok := f.GlyphBounds(c)
-		if !ok {
-			// TODO: is falling back on the U+FFFD glyph the responsibility of
-			// the Drawer or the Face?
-			// TODO: set prevC = '\ufffd'?
-			continue
-		}
-		b.Min.X += advance
-		b.Max.X += advance
-		bounds = bounds.Union(b)
-		advance += a
-		prevC = c
-	}
-	return
-}
-
-// BoundString returns the bounding box of s with f, drawn at a dot equal to the
-// origin, as well as the advance.
-func BoundString(f Face, s string) (bounds fixed.Rectangle26_6, advance fixed.Int26_6) {
-	prevC := rune(-1)
-	for _, c := range s {
-		if prevC >= 0 {
-			advance += f.Kern(prevC, c)
-		}
-		b, a, ok := f.GlyphBounds(c)
-		if !ok {
-			// TODO: is falling back on the U+FFFD glyph the responsibility of
-			// the Drawer or the Face?
-			// TODO: set prevC = '\ufffd'?
-			continue
-		}
-		b.Min.X += advance
-		b.Max.X += advance
-		bounds = bounds.Union(b)
-		advance += a
-		prevC = c
-	}
-	return
-}
-
-// MeasureBytes returns how far dot would advance by drawing s with f.
-//
-// It is equivalent to MeasureString(string(s)) but may be more efficient.
-func MeasureBytes(f Face, s []byte) (advance fixed.Int26_6) {
-	prevC := rune(-1)
-	for len(s) > 0 {
-		c, size := utf8.DecodeRune(s)
-		s = s[size:]
-		if prevC >= 0 {
-			advance += f.Kern(prevC, c)
-		}
-		a, ok := f.GlyphAdvance(c)
-		if !ok {
-			// TODO: is falling back on the U+FFFD glyph the responsibility of
-			// the Drawer or the Face?
-			// TODO: set prevC = '\ufffd'?
-			continue
-		}
-		advance += a
-		prevC = c
-	}
-	return advance
-}
-
-// MeasureString returns how far dot would advance by drawing s with f.
-func MeasureString(f Face, s string) (advance fixed.Int26_6) {
-	prevC := rune(-1)
-	for _, c := range s {
-		if prevC >= 0 {
-			advance += f.Kern(prevC, c)
-		}
-		a, ok := f.GlyphAdvance(c)
-		if !ok {
-			// TODO: is falling back on the U+FFFD glyph the responsibility of
-			// the Drawer or the Face?
-			// TODO: set prevC = '\ufffd'?
-			continue
-		}
-		advance += a
-		prevC = c
-	}
-	return advance
-}
-
-// Hinting selects how to quantize a vector font's glyph nodes.
-//
-// Not all fonts support hinting.
-type Hinting int
-
-const (
-	HintingNone Hinting = iota
-	HintingVertical
-	HintingFull
-)
-
-// Stretch selects a normal, condensed, or expanded face.
-//
-// Not all fonts support stretches.
-type Stretch int
-
-const (
-	StretchUltraCondensed Stretch = -4
-	StretchExtraCondensed Stretch = -3
-	StretchCondensed      Stretch = -2
-	StretchSemiCondensed  Stretch = -1
-	StretchNormal         Stretch = +0
-	StretchSemiExpanded   Stretch = +1
-	StretchExpanded       Stretch = +2
-	StretchExtraExpanded  Stretch = +3
-	StretchUltraExpanded  Stretch = +4
-)
-
-// Style selects a normal, italic, or oblique face.
-//
-// Not all fonts support styles.
-type Style int
-
-const (
-	StyleNormal Style = iota
-	StyleItalic
-	StyleOblique
-)
-
-// Weight selects a normal, light or bold face.
-//
-// Not all fonts support weights.
-//
-// The named Weight constants (e.g. WeightBold) correspond to CSS' common
-// weight names (e.g. "Bold"), but the numerical values differ, so that in Go,
-// the zero value means to use a normal weight. For the CSS names and values,
-// see https://developer.mozilla.org/en/docs/Web/CSS/font-weight
-type Weight int
-
-const (
-	WeightThin       Weight = -3 // CSS font-weight value 100.
-	WeightExtraLight Weight = -2 // CSS font-weight value 200.
-	WeightLight      Weight = -1 // CSS font-weight value 300.
-	WeightNormal     Weight = +0 // CSS font-weight value 400.
-	WeightMedium     Weight = +1 // CSS font-weight value 500.
-	WeightSemiBold   Weight = +2 // CSS font-weight value 600.
-	WeightBold       Weight = +3 // CSS font-weight value 700.
-	WeightExtraBold  Weight = +4 // CSS font-weight value 800.
-	WeightBlack      Weight = +5 // CSS font-weight value 900.
-)

vendor/golang.org/x/image/font/font_test.go

@@ -1,65 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package font
-
-import (
-	"image"
-	"strings"
-	"testing"
-
-	"golang.org/x/image/math/fixed"
-)
-
-const toyAdvance = fixed.Int26_6(10 << 6)
-
-type toyFace struct{}
-
-func (toyFace) Close() error {
-	return nil
-}
-
-func (toyFace) Glyph(dot fixed.Point26_6, r rune) (image.Rectangle, image.Image, image.Point, fixed.Int26_6, bool) {
-	panic("unimplemented")
-}
-
-func (toyFace) GlyphBounds(r rune) (fixed.Rectangle26_6, fixed.Int26_6, bool) {
-	return fixed.Rectangle26_6{
-		Min: fixed.P(2, 0),
-		Max: fixed.P(6, 1),
-	}, toyAdvance, true
-}
-
-func (toyFace) GlyphAdvance(r rune) (fixed.Int26_6, bool) {
-	return toyAdvance, true
-}
-
-func (toyFace) Kern(r0, r1 rune) fixed.Int26_6 {
-	return 0
-}
-
-func (toyFace) Metrics() Metrics {
-	return Metrics{}
-}
-
-func TestBound(t *testing.T) {
-	wantBounds := []fixed.Rectangle26_6{
-		{Min: fixed.P(0, 0), Max: fixed.P(0, 0)},
-		{Min: fixed.P(2, 0), Max: fixed.P(6, 1)},
-		{Min: fixed.P(2, 0), Max: fixed.P(16, 1)},
-		{Min: fixed.P(2, 0), Max: fixed.P(26, 1)},
-	}
-
-	for i, wantBound := range wantBounds {
-		s := strings.Repeat("x", i)
-		gotBound, gotAdvance := BoundString(toyFace{}, s)
-		if gotBound != wantBound {
-			t.Errorf("i=%d: bound: got %v, want %v", i, gotBound, wantBound)
-		}
-		wantAdvance := toyAdvance * fixed.Int26_6(i)
-		if gotAdvance != wantAdvance {
-			t.Errorf("i=%d: advance: got %v, want %v", i, gotAdvance, wantAdvance)
-		}
-	}
-}

vendor/golang.org/x/image/font/gofont/gen.go

@@ -1,107 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-// This program generates the subdirectories of Go packages that contain []byte
-// versions of the TrueType font files under ./ttfs.
-//
-// Currently, "go run gen.go" needs to be run manually. This isn't done by the
-// usual "go generate" mechanism as there isn't any other Go code in this
-// directory (excluding sub-directories) to attach a "go:generate" line to.
-//
-// In any case, code generation should only need to happen when the underlying
-// TTF files change, which isn't expected to happen frequently.
-
-import (
-	"bytes"
-	"fmt"
-	"go/format"
-	"io/ioutil"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-const suffix = ".ttf"
-
-func main() {
-	ttfs, err := os.Open("ttfs")
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer ttfs.Close()
-
-	infos, err := ttfs.Readdir(-1)
-	if err != nil {
-		log.Fatal(err)
-	}
-	for _, info := range infos {
-		ttfName := info.Name()
-		if !strings.HasSuffix(ttfName, suffix) {
-			continue
-		}
-		do(ttfName)
-	}
-}
-
-func do(ttfName string) {
-	fontName := fontName(ttfName)
-	pkgName := pkgName(ttfName)
-	if err := os.Mkdir(pkgName, 0777); err != nil && !os.IsExist(err) {
-		log.Fatal(err)
-	}
-	src, err := ioutil.ReadFile(filepath.Join("ttfs", ttfName))
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	desc := "a proportional-width, sans-serif"
-	if strings.Contains(ttfName, "Mono") {
-		desc = "a fixed-width, slab-serif"
-	}
-
-	b := new(bytes.Buffer)
-	fmt.Fprintf(b, "// generated by go run gen.go; DO NOT EDIT\n\n")
-	fmt.Fprintf(b, "// Package %s provides the %q TrueType font\n", pkgName, fontName)
-	fmt.Fprintf(b, "// from the Go font family. It is %s font.\n", desc)
-	fmt.Fprintf(b, "//\n")
-	fmt.Fprintf(b, "// See https://blog.golang.org/go-fonts for details.\n")
-	fmt.Fprintf(b, "package %s\n\n", pkgName)
-	fmt.Fprintf(b, "// TTF is the data for the %q TrueType font.\n", fontName)
-	fmt.Fprintf(b, "var TTF = []byte{")
-	for i, x := range src {
-		if i&15 == 0 {
-			b.WriteByte('\n')
-		}
-		fmt.Fprintf(b, "%#02x,", x)
-	}
-	fmt.Fprintf(b, "\n}\n")
-
-	dst, err := format.Source(b.Bytes())
-	if err != nil {
-		log.Fatal(err)
-	}
-	if err := ioutil.WriteFile(filepath.Join(pkgName, "data.go"), dst, 0666); err != nil {
-		log.Fatal(err)
-	}
-}
-
-// fontName maps "Go-Regular.ttf" to "Go Regular".
-func fontName(ttfName string) string {
-	s := ttfName[:len(ttfName)-len(suffix)]
-	s = strings.Replace(s, "-", " ", -1)
-	return s
-}
-
-// pkgName maps "Go-Regular.ttf" to "goregular".
-func pkgName(ttfName string) string {
-	s := ttfName[:len(ttfName)-len(suffix)]
-	s = strings.Replace(s, "-", "", -1)
-	s = strings.ToLower(s)
-	return s
-}