From 14bb08c1df8db9ec6c8a05520d4eee67971235d9 Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Thu, 27 Sep 2018 20:03:23 +0200 Subject: mod tidy --- vendor/golang.org/x/image/draw/draw.go | 43 - vendor/golang.org/x/image/draw/gen.go | 1404 ------- vendor/golang.org/x/image/draw/go1_8.go | 49 - vendor/golang.org/x/image/draw/go1_9.go | 57 - vendor/golang.org/x/image/draw/impl.go | 6670 ------------------------------- vendor/golang.org/x/image/draw/scale.go | 527 --- 6 files changed, 8750 deletions(-) delete mode 100644 vendor/golang.org/x/image/draw/draw.go delete mode 100644 vendor/golang.org/x/image/draw/gen.go delete mode 100644 vendor/golang.org/x/image/draw/go1_8.go delete mode 100644 vendor/golang.org/x/image/draw/go1_9.go delete mode 100644 vendor/golang.org/x/image/draw/impl.go delete mode 100644 vendor/golang.org/x/image/draw/scale.go (limited to 'vendor/golang.org/x/image/draw') diff --git a/vendor/golang.org/x/image/draw/draw.go b/vendor/golang.org/x/image/draw/draw.go deleted file mode 100644 index dfaa7fc..0000000 --- a/vendor/golang.org/x/image/draw/draw.go +++ /dev/null @@ -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) -} diff --git a/vendor/golang.org/x/image/draw/gen.go b/vendor/golang.org/x/image/draw/gen.go deleted file mode 100644 index 822bb6a..0000000 --- a/vendor/golang.org/x/image/draw/gen.go +++ /dev/null @@ -1,1404 +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 - -package main - -import ( - "bytes" - "flag" - "fmt" - "go/format" - "io/ioutil" - "log" - "os" - "strings" -) - -var debug = flag.Bool("debug", false, "") - -func main() { - flag.Parse() - - w := new(bytes.Buffer) - w.WriteString("// generated by \"go run gen.go\". DO NOT EDIT.\n\n" + - "package draw\n\nimport (\n" + - "\"image\"\n" + - "\"image/color\"\n" + - "\"math\"\n" + - "\n" + - "\"golang.org/x/image/math/f64\"\n" + - ")\n") - - gen(w, "nnInterpolator", codeNNScaleLeaf, codeNNTransformLeaf) - gen(w, "ablInterpolator", codeABLScaleLeaf, codeABLTransformLeaf) - genKernel(w) - - if *debug { - os.Stdout.Write(w.Bytes()) - return - } - out, err := format.Source(w.Bytes()) - if err != nil { - log.Fatal(err) - } - if err := ioutil.WriteFile("impl.go", out, 0660); err != nil { - log.Fatal(err) - } -} - -var ( - // dsTypes are the (dst image type, src image type) pairs to generate - // scale_DType_SType implementations for. The last element in the slice - // should be the fallback pair ("Image", "image.Image"). - // - // TODO: add *image.CMYK src type after Go 1.5 is released. - // An *image.CMYK is also alwaysOpaque. - dsTypes = []struct{ dType, sType string }{ - {"*image.RGBA", "*image.Gray"}, - {"*image.RGBA", "*image.NRGBA"}, - {"*image.RGBA", "*image.RGBA"}, - {"*image.RGBA", "*image.YCbCr"}, - {"*image.RGBA", "image.Image"}, - {"Image", "image.Image"}, - } - dTypes, sTypes []string - sTypesForDType = map[string][]string{} - subsampleRatios = []string{ - "444", - "422", - "420", - "440", - } - ops = []string{"Over", "Src"} - // alwaysOpaque are those image.Image implementations that are always - // opaque. For these types, Over is equivalent to the faster Src, in the - // absence of a source mask. - alwaysOpaque = map[string]bool{ - "*image.Gray": true, - "*image.YCbCr": true, - } -) - -func init() { - dTypesSeen := map[string]bool{} - sTypesSeen := map[string]bool{} - for _, t := range dsTypes { - if !sTypesSeen[t.sType] { - sTypesSeen[t.sType] = true - sTypes = append(sTypes, t.sType) - } - if !dTypesSeen[t.dType] { - dTypesSeen[t.dType] = true - dTypes = append(dTypes, t.dType) - } - sTypesForDType[t.dType] = append(sTypesForDType[t.dType], t.sType) - } - sTypesForDType["anyDType"] = sTypes -} - -type data struct { - dType string - sType string - sratio string - receiver string - op string -} - -func gen(w *bytes.Buffer, receiver string, codes ...string) { - expn(w, codeRoot, &data{receiver: receiver}) - for _, code := range codes { - for _, t := range dsTypes { - for _, op := range ops { - if op == "Over" && alwaysOpaque[t.sType] { - continue - } - expn(w, code, &data{ - dType: t.dType, - sType: t.sType, - receiver: receiver, - op: op, - }) - } - } - } -} - -func genKernel(w *bytes.Buffer) { - expn(w, codeKernelRoot, &data{}) - for _, sType := range sTypes { - expn(w, codeKernelScaleLeafX, &data{ - sType: sType, - }) - } - for _, dType := range dTypes { - for _, op := range ops { - expn(w, codeKernelScaleLeafY, &data{ - dType: dType, - op: op, - }) - } - } - for _, t := range dsTypes { - for _, op := range ops { - if op == "Over" && alwaysOpaque[t.sType] { - continue - } - expn(w, codeKernelTransformLeaf, &data{ - dType: t.dType, - sType: t.sType, - op: op, - }) - } - } -} - -func expn(w *bytes.Buffer, code string, d *data) { - if d.sType == "*image.YCbCr" && d.sratio == "" { - for _, sratio := range subsampleRatios { - e := *d - e.sratio = sratio - expn(w, code, &e) - } - return - } - - for _, line := range strings.Split(code, "\n") { - line = expnLine(line, d) - if line == ";" { - continue - } - fmt.Fprintln(w, line) - } -} - -func expnLine(line string, d *data) string { - for { - i := strings.IndexByte(line, '$') - if i < 0 { - break - } - prefix, s := line[:i], line[i+1:] - - i = len(s) - for j, c := range s { - if !('A' <= c && c <= 'Z' || 'a' <= c && c <= 'z') { - i = j - break - } - } - dollar, suffix := s[:i], s[i:] - - e := expnDollar(prefix, dollar, suffix, d) - if e == "" { - log.Fatalf("couldn't expand %q", line) - } - line = e - } - return line -} - -// expnDollar expands a "$foo" fragment in a line of generated code. It returns -// the empty string if there was a problem. It returns ";" if the generated -// code is a no-op. -func expnDollar(prefix, dollar, suffix string, d *data) string { - switch dollar { - case "dType": - return prefix + d.dType + suffix - case "dTypeRN": - return prefix + relName(d.dType) + suffix - case "sratio": - return prefix + d.sratio + suffix - case "sType": - return prefix + d.sType + suffix - case "sTypeRN": - return prefix + relName(d.sType) + suffix - case "receiver": - return prefix + d.receiver + suffix - case "op": - return prefix + d.op + suffix - - case "switch": - return expnSwitch("", "", true, suffix) - case "switchD": - return expnSwitch("", "", false, suffix) - case "switchS": - return expnSwitch("", "anyDType", false, suffix) - - case "preOuter": - switch d.dType { - default: - return ";" - case "Image": - s := "" - if d.sType == "image.Image" { - s = "srcMask, smp := opts.SrcMask, opts.SrcMaskP\n" - } - return s + - "dstMask, dmp := opts.DstMask, opts.DstMaskP\n" + - "dstColorRGBA64 := &color.RGBA64{}\n" + - "dstColor := color.Color(dstColorRGBA64)" - } - - case "preInner": - switch d.dType { - default: - return ";" - case "*image.RGBA": - return "d := " + pixOffset("dst", "dr.Min.X+adr.Min.X", "dr.Min.Y+int(dy)", "*4", "*dst.Stride") - } - - case "preKernelOuter": - switch d.sType { - default: - return ";" - case "image.Image": - return "srcMask, smp := opts.SrcMask, opts.SrcMaskP" - } - - case "preKernelInner": - switch d.dType { - default: - return ";" - case "*image.RGBA": - return "d := " + pixOffset("dst", "dr.Min.X+int(dx)", "dr.Min.Y+adr.Min.Y", "*4", "*dst.Stride") - } - - case "blend": - args, _ := splitArgs(suffix) - if len(args) != 4 { - return "" - } - switch d.sType { - default: - return argf(args, ""+ - "$3r = $0*$1r + $2*$3r\n"+ - "$3g = $0*$1g + $2*$3g\n"+ - "$3b = $0*$1b + $2*$3b\n"+ - "$3a = $0*$1a + $2*$3a", - ) - case "*image.Gray": - return argf(args, ""+ - "$3r = $0*$1r + $2*$3r", - ) - case "*image.YCbCr": - return argf(args, ""+ - "$3r = $0*$1r + $2*$3r\n"+ - "$3g = $0*$1g + $2*$3g\n"+ - "$3b = $0*$1b + $2*$3b", - ) - } - - case "clampToAlpha": - if alwaysOpaque[d.sType] { - return ";" - } - // Go uses alpha-premultiplied color. The naive computation can lead to - // invalid colors, e.g. red > alpha, when some weights are negative. - return ` - if pr > pa { - pr = pa - } - if pg > pa { - pg = pa - } - if pb > pa { - pb = pa - } - ` - - case "convFtou": - args, _ := splitArgs(suffix) - if len(args) != 2 { - return "" - } - - switch d.sType { - default: - return argf(args, ""+ - "$0r := uint32($1r)\n"+ - "$0g := uint32($1g)\n"+ - "$0b := uint32($1b)\n"+ - "$0a := uint32($1a)", - ) - case "*image.Gray": - return argf(args, ""+ - "$0r := uint32($1r)", - ) - case "*image.YCbCr": - return argf(args, ""+ - "$0r := uint32($1r)\n"+ - "$0g := uint32($1g)\n"+ - "$0b := uint32($1b)", - ) - } - - case "outputu": - args, _ := splitArgs(suffix) - if len(args) != 3 { - return "" - } - - switch d.op { - case "Over": - switch d.dType { - default: - log.Fatalf("bad dType %q", d.dType) - case "Image": - return argf(args, ""+ - "qr, qg, qb, qa := dst.At($0, $1).RGBA()\n"+ - "if dstMask != nil {\n"+ - " _, _, _, ma := dstMask.At(dmp.X + $0, dmp.Y + $1).RGBA()\n"+ - " $2r = $2r * ma / 0xffff\n"+ - " $2g = $2g * ma / 0xffff\n"+ - " $2b = $2b * ma / 0xffff\n"+ - " $2a = $2a * ma / 0xffff\n"+ - "}\n"+ - "$2a1 := 0xffff - $2a\n"+ - "dstColorRGBA64.R = uint16(qr*$2a1/0xffff + $2r)\n"+ - "dstColorRGBA64.G = uint16(qg*$2a1/0xffff + $2g)\n"+ - "dstColorRGBA64.B = uint16(qb*$2a1/0xffff + $2b)\n"+ - "dstColorRGBA64.A = uint16(qa*$2a1/0xffff + $2a)\n"+ - "dst.Set($0, $1, dstColor)", - ) - case "*image.RGBA": - return argf(args, ""+ - "$2a1 := (0xffff - $2a) * 0x101\n"+ - "dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*$2a1/0xffff + $2r) >> 8)\n"+ - "dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*$2a1/0xffff + $2g) >> 8)\n"+ - "dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*$2a1/0xffff + $2b) >> 8)\n"+ - "dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*$2a1/0xffff + $2a) >> 8)", - ) - } - - case "Src": - switch d.dType { - default: - log.Fatalf("bad dType %q", d.dType) - case "Image": - return argf(args, ""+ - "if dstMask != nil {\n"+ - " qr, qg, qb, qa := dst.At($0, $1).RGBA()\n"+ - " _, _, _, ma := dstMask.At(dmp.X + $0, dmp.Y + $1).RGBA()\n"+ - " pr = pr * ma / 0xffff\n"+ - " pg = pg * ma / 0xffff\n"+ - " pb = pb * ma / 0xffff\n"+ - " pa = pa * ma / 0xffff\n"+ - " $2a1 := 0xffff - ma\n"+ // Note that this is ma, not $2a. - " dstColorRGBA64.R = uint16(qr*$2a1/0xffff + $2r)\n"+ - " dstColorRGBA64.G = uint16(qg*$2a1/0xffff + $2g)\n"+ - " dstColorRGBA64.B = uint16(qb*$2a1/0xffff + $2b)\n"+ - " dstColorRGBA64.A = uint16(qa*$2a1/0xffff + $2a)\n"+ - " dst.Set($0, $1, dstColor)\n"+ - "} else {\n"+ - " dstColorRGBA64.R = uint16($2r)\n"+ - " dstColorRGBA64.G = uint16($2g)\n"+ - " dstColorRGBA64.B = uint16($2b)\n"+ - " dstColorRGBA64.A = uint16($2a)\n"+ - " dst.Set($0, $1, dstColor)\n"+ - "}", - ) - case "*image.RGBA": - switch d.sType { - default: - return argf(args, ""+ - "dst.Pix[d+0] = uint8($2r >> 8)\n"+ - "dst.Pix[d+1] = uint8($2g >> 8)\n"+ - "dst.Pix[d+2] = uint8($2b >> 8)\n"+ - "dst.Pix[d+3] = uint8($2a >> 8)", - ) - case "*image.Gray": - return argf(args, ""+ - "out := uint8($2r >> 8)\n"+ - "dst.Pix[d+0] = out\n"+ - "dst.Pix[d+1] = out\n"+ - "dst.Pix[d+2] = out\n"+ - "dst.Pix[d+3] = 0xff", - ) - case "*image.YCbCr": - return argf(args, ""+ - "dst.Pix[d+0] = uint8($2r >> 8)\n"+ - "dst.Pix[d+1] = uint8($2g >> 8)\n"+ - "dst.Pix[d+2] = uint8($2b >> 8)\n"+ - "dst.Pix[d+3] = 0xff", - ) - } - } - } - - case "outputf": - args, _ := splitArgs(suffix) - if len(args) != 5 { - return "" - } - ret := "" - - switch d.op { - case "Over": - switch d.dType { - default: - log.Fatalf("bad dType %q", d.dType) - case "Image": - ret = argf(args, ""+ - "qr, qg, qb, qa := dst.At($0, $1).RGBA()\n"+ - "$3r0 := uint32($2($3r * $4))\n"+ - "$3g0 := uint32($2($3g * $4))\n"+ - "$3b0 := uint32($2($3b * $4))\n"+ - "$3a0 := uint32($2($3a * $4))\n"+ - "if dstMask != nil {\n"+ - " _, _, _, ma := dstMask.At(dmp.X + $0, dmp.Y + $1).RGBA()\n"+ - " $3r0 = $3r0 * ma / 0xffff\n"+ - " $3g0 = $3g0 * ma / 0xffff\n"+ - " $3b0 = $3b0 * ma / 0xffff\n"+ - " $3a0 = $3a0 * ma / 0xffff\n"+ - "}\n"+ - "$3a1 := 0xffff - $3a0\n"+ - "dstColorRGBA64.R = uint16(qr*$3a1/0xffff + $3r0)\n"+ - "dstColorRGBA64.G = uint16(qg*$3a1/0xffff + $3g0)\n"+ - "dstColorRGBA64.B = uint16(qb*$3a1/0xffff + $3b0)\n"+ - "dstColorRGBA64.A = uint16(qa*$3a1/0xffff + $3a0)\n"+ - "dst.Set($0, $1, dstColor)", - ) - case "*image.RGBA": - ret = argf(args, ""+ - "$3r0 := uint32($2($3r * $4))\n"+ - "$3g0 := uint32($2($3g * $4))\n"+ - "$3b0 := uint32($2($3b * $4))\n"+ - "$3a0 := uint32($2($3a * $4))\n"+ - "$3a1 := (0xffff - uint32($3a0)) * 0x101\n"+ - "dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*$3a1/0xffff + $3r0) >> 8)\n"+ - "dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*$3a1/0xffff + $3g0) >> 8)\n"+ - "dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*$3a1/0xffff + $3b0) >> 8)\n"+ - "dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*$3a1/0xffff + $3a0) >> 8)", - ) - } - - case "Src": - switch d.dType { - default: - log.Fatalf("bad dType %q", d.dType) - case "Image": - ret = argf(args, ""+ - "if dstMask != nil {\n"+ - " qr, qg, qb, qa := dst.At($0, $1).RGBA()\n"+ - " _, _, _, ma := dstMask.At(dmp.X + $0, dmp.Y + $1).RGBA()\n"+ - " pr := uint32($2($3r * $4)) * ma / 0xffff\n"+ - " pg := uint32($2($3g * $4)) * ma / 0xffff\n"+ - " pb := uint32($2($3b * $4)) * ma / 0xffff\n"+ - " pa := uint32($2($3a * $4)) * ma / 0xffff\n"+ - " pa1 := 0xffff - ma\n"+ // Note that this is ma, not pa. - " dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr)\n"+ - " dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg)\n"+ - " dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb)\n"+ - " dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa)\n"+ - " dst.Set($0, $1, dstColor)\n"+ - "} else {\n"+ - " dstColorRGBA64.R = $2($3r * $4)\n"+ - " dstColorRGBA64.G = $2($3g * $4)\n"+ - " dstColorRGBA64.B = $2($3b * $4)\n"+ - " dstColorRGBA64.A = $2($3a * $4)\n"+ - " dst.Set($0, $1, dstColor)\n"+ - "}", - ) - case "*image.RGBA": - switch d.sType { - default: - ret = argf(args, ""+ - "dst.Pix[d+0] = uint8($2($3r * $4) >> 8)\n"+ - "dst.Pix[d+1] = uint8($2($3g * $4) >> 8)\n"+ - "dst.Pix[d+2] = uint8($2($3b * $4) >> 8)\n"+ - "dst.Pix[d+3] = uint8($2($3a * $4) >> 8)", - ) - case "*image.Gray": - ret = argf(args, ""+ - "out := uint8($2($3r * $4) >> 8)\n"+ - "dst.Pix[d+0] = out\n"+ - "dst.Pix[d+1] = out\n"+ - "dst.Pix[d+2] = out\n"+ - "dst.Pix[d+3] = 0xff", - ) - case "*image.YCbCr": - ret = argf(args, ""+ - "dst.Pix[d+0] = uint8($2($3r * $4) >> 8)\n"+ - "dst.Pix[d+1] = uint8($2($3g * $4) >> 8)\n"+ - "dst.Pix[d+2] = uint8($2($3b * $4) >> 8)\n"+ - "dst.Pix[d+3] = 0xff", - ) - } - } - } - - return strings.Replace(ret, " * 1)", ")", -1) - - case "srcf", "srcu": - lhs, eqOp := splitEq(prefix) - if lhs == "" { - return "" - } - args, extra := splitArgs(suffix) - if len(args) != 2 { - return "" - } - - tmp := "" - if dollar == "srcf" { - tmp = "u" - } - - // TODO: there's no need to multiply by 0x101 in the switch below if - // the next thing we're going to do is shift right by 8. - - buf := new(bytes.Buffer) - switch d.sType { - default: - log.Fatalf("bad sType %q", d.sType) - case "image.Image": - fmt.Fprintf(buf, ""+ - "%sr%s, %sg%s, %sb%s, %sa%s := src.At(%s, %s).RGBA()\n", - lhs, tmp, lhs, tmp, lhs, tmp, lhs, tmp, args[0], args[1], - ) - if d.dType == "" || d.dType == "Image" { - fmt.Fprintf(buf, ""+ - "if srcMask != nil {\n"+ - " _, _, _, ma := srcMask.At(smp.X+%s, smp.Y+%s).RGBA()\n"+ - " %sr%s = %sr%s * ma / 0xffff\n"+ - " %sg%s = %sg%s * ma / 0xffff\n"+ - " %sb%s = %sb%s * ma / 0xffff\n"+ - " %sa%s = %sa%s * ma / 0xffff\n"+ - "}\n", - args[0], args[1], - lhs, tmp, lhs, tmp, - lhs, tmp, lhs, tmp, - lhs, tmp, lhs, tmp, - lhs, tmp, lhs, tmp, - ) - } - case "*image.Gray": - fmt.Fprintf(buf, ""+ - "%si := %s\n"+ - "%sr%s := uint32(src.Pix[%si]) * 0x101\n", - lhs, pixOffset("src", args[0], args[1], "", "*src.Stride"), - lhs, tmp, lhs, - ) - case "*image.NRGBA": - fmt.Fprintf(buf, ""+ - "%si := %s\n"+ - "%sa%s := uint32(src.Pix[%si+3]) * 0x101\n"+ - "%sr%s := uint32(src.Pix[%si+0]) * %sa%s / 0xff\n"+ - "%sg%s := uint32(src.Pix[%si+1]) * %sa%s / 0xff\n"+ - "%sb%s := uint32(src.Pix[%si+2]) * %sa%s / 0xff\n", - lhs, pixOffset("src", args[0], args[1], "*4", "*src.Stride"), - lhs, tmp, lhs, - lhs, tmp, lhs, lhs, tmp, - lhs, tmp, lhs, lhs, tmp, - lhs, tmp, lhs, lhs, tmp, - ) - case "*image.RGBA": - fmt.Fprintf(buf, ""+ - "%si := %s\n"+ - "%sr%s := uint32(src.Pix[%si+0]) * 0x101\n"+ - "%sg%s := uint32(src.Pix[%si+1]) * 0x101\n"+ - "%sb%s := uint32(src.Pix[%si+2]) * 0x101\n"+ - "%sa%s := uint32(src.Pix[%si+3]) * 0x101\n", - lhs, pixOffset("src", args[0], args[1], "*4", "*src.Stride"), - lhs, tmp, lhs, - lhs, tmp, lhs, - lhs, tmp, lhs, - lhs, tmp, lhs, - ) - case "*image.YCbCr": - fmt.Fprintf(buf, ""+ - "%si := %s\n"+ - "%sj := %s\n"+ - "%s\n", - lhs, pixOffset("src", args[0], args[1], "", "*src.YStride"), - lhs, cOffset(args[0], args[1], d.sratio), - ycbcrToRGB(lhs, tmp), - ) - } - - if dollar == "srcf" { - switch d.sType { - default: - fmt.Fprintf(buf, ""+ - "%sr %s float64(%sru)%s\n"+ - "%sg %s float64(%sgu)%s\n"+ - "%sb %s float64(%sbu)%s\n"+ - "%sa %s float64(%sau)%s\n", - lhs, eqOp, lhs, extra, - lhs, eqOp, lhs, extra, - lhs, eqOp, lhs, extra, - lhs, eqOp, lhs, extra, - ) - case "*image.Gray": - fmt.Fprintf(buf, ""+ - "%sr %s float64(%sru)%s\n", - lhs, eqOp, lhs, extra, - ) - case "*image.YCbCr": - fmt.Fprintf(buf, ""+ - "%sr %s float64(%sru)%s\n"+ - "%sg %s float64(%sgu)%s\n"+ - "%sb %s float64(%sbu)%s\n", - lhs, eqOp, lhs, extra, - lhs, eqOp, lhs, extra, - lhs, eqOp, lhs, extra, - ) - } - } - - return strings.TrimSpace(buf.String()) - - case "tweakD": - if d.dType == "*image.RGBA" { - return "d += dst.Stride" - } - return ";" - - case "tweakDx": - if d.dType == "*image.RGBA" { - return strings.Replace(prefix, "dx++", "dx, d = dx+1, d+4", 1) - } - return prefix - - case "tweakDy": - if d.dType == "*image.RGBA" { - return strings.Replace(prefix, "for dy, s", "for _, s", 1) - } - return prefix - - case "tweakP": - switch d.sType { - case "*image.Gray": - if strings.HasPrefix(strings.TrimSpace(prefix), "pa * ") { - return "1," - } - return "pr," - case "*image.YCbCr": - if strings.HasPrefix(strings.TrimSpace(prefix), "pa * ") { - return "1," - } - } - return prefix - - case "tweakPr": - if d.sType == "*image.Gray" { - return "pr *= s.invTotalWeightFFFF" - } - return ";" - - case "tweakVarP": - switch d.sType { - case "*image.Gray": - return strings.Replace(prefix, "var pr, pg, pb, pa", "var pr", 1) - case "*image.YCbCr": - return strings.Replace(prefix, "var pr, pg, pb, pa", "var pr, pg, pb", 1) - } - return prefix - } - return "" -} - -func expnSwitch(op, dType string, expandBoth bool, template string) string { - if op == "" && dType != "anyDType" { - lines := []string{"switch op {"} - for _, op = range ops { - lines = append(lines, - fmt.Sprintf("case %s:", op), - expnSwitch(op, dType, expandBoth, template), - ) - } - lines = append(lines, "}") - return strings.Join(lines, "\n") - } - - switchVar := "dst" - if dType != "" { - switchVar = "src" - } - lines := []string{fmt.Sprintf("switch %s := %s.(type) {", switchVar, switchVar)} - - fallback, values := "Image", dTypes - if dType != "" { - fallback, values = "image.Image", sTypesForDType[dType] - } - for _, v := range values { - if dType != "" { - // v is the sType. Skip those always-opaque sTypes, where Over is - // equivalent to Src. - if op == "Over" && alwaysOpaque[v] { - continue - } - } - - if v == fallback { - lines = append(lines, "default:") - } else { - lines = append(lines, fmt.Sprintf("case %s:", v)) - } - - if dType != "" { - if v == "*image.YCbCr" { - lines = append(lines, expnSwitchYCbCr(op, dType, template)) - } else { - lines = append(lines, expnLine(template, &data{dType: dType, sType: v, op: op})) - } - } else if !expandBoth { - lines = append(lines, expnLine(template, &data{dType: v, op: op})) - } else { - lines = append(lines, expnSwitch(op, v, false, template)) - } - } - - lines = append(lines, "}") - return strings.Join(lines, "\n") -} - -func expnSwitchYCbCr(op, dType, template string) string { - lines := []string{ - "switch src.SubsampleRatio {", - "default:", - expnLine(template, &data{dType: dType, sType: "image.Image", op: op}), - } - for _, sratio := range subsampleRatios { - lines = append(lines, - fmt.Sprintf("case image.YCbCrSubsampleRatio%s:", sratio), - expnLine(template, &data{dType: dType, sType: "*image.YCbCr", sratio: sratio, op: op}), - ) - } - lines = append(lines, "}") - return strings.Join(lines, "\n") -} - -func argf(args []string, s string) string { - if len(args) > 9 { - panic("too many args") - } - for i, a := range args { - old := fmt.Sprintf("$%d", i) - s = strings.Replace(s, old, a, -1) - } - return s -} - -func pixOffset(m, x, y, xstride, ystride string) string { - return fmt.Sprintf("(%s-%s.Rect.Min.Y)%s + (%s-%s.Rect.Min.X)%s", y, m, ystride, x, m, xstride) -} - -func cOffset(x, y, sratio string) string { - switch sratio { - case "444": - return fmt.Sprintf("( %s - src.Rect.Min.Y )*src.CStride + ( %s - src.Rect.Min.X )", y, x) - case "422": - return fmt.Sprintf("( %s - src.Rect.Min.Y )*src.CStride + ((%s)/2 - src.Rect.Min.X/2)", y, x) - case "420": - return fmt.Sprintf("((%s)/2 - src.Rect.Min.Y/2)*src.CStride + ((%s)/2 - src.Rect.Min.X/2)", y, x) - case "440": - return fmt.Sprintf("((%s)/2 - src.Rect.Min.Y/2)*src.CStride + ( %s - src.Rect.Min.X )", y, x) - } - return fmt.Sprintf("unsupported sratio %q", sratio) -} - -func ycbcrToRGB(lhs, tmp string) string { - s := ` - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - $yy1 := int(src.Y[$i]) * 0x10101 - $cb1 := int(src.Cb[$j]) - 128 - $cr1 := int(src.Cr[$j]) - 128 - $r@ := ($yy1 + 91881*$cr1) >> 8 - $g@ := ($yy1 - 22554*$cb1 - 46802*$cr1) >> 8 - $b@ := ($yy1 + 116130*$cb1) >> 8 - if $r@ < 0 { - $r@ = 0 - } else if $r@ > 0xffff { - $r@ = 0xffff - } - if $g@ < 0 { - $g@ = 0 - } else if $g@ > 0xffff { - $g@ = 0xffff - } - if $b@ < 0 { - $b@ = 0 - } else if $b@ > 0xffff { - $b@ = 0xffff - } - ` - s = strings.Replace(s, "$", lhs, -1) - s = strings.Replace(s, "@", tmp, -1) - return s -} - -func split(s, sep string) (string, string) { - if i := strings.Index(s, sep); i >= 0 { - return strings.TrimSpace(s[:i]), strings.TrimSpace(s[i+len(sep):]) - } - return "", "" -} - -func splitEq(s string) (lhs, eqOp string) { - s = strings.TrimSpace(s) - if lhs, _ = split(s, ":="); lhs != "" { - return lhs, ":=" - } - if lhs, _ = split(s, "+="); lhs != "" { - return lhs, "+=" - } - return "", "" -} - -func splitArgs(s string) (args []string, extra string) { - s = strings.TrimSpace(s) - if s == "" || s[0] != '[' { - return nil, "" - } - s = s[1:] - - i := strings.IndexByte(s, ']') - if i < 0 { - return nil, "" - } - args, extra = strings.Split(s[:i], ","), s[i+1:] - for i := range args { - args[i] = strings.TrimSpace(args[i]) - } - return args, extra -} - -func relName(s string) string { - if i := strings.LastIndex(s, "."); i >= 0 { - return s[i+1:] - } - return s -} - -const ( - codeRoot = ` - func (z $receiver) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) { - // Try to simplify a Scale to a Copy when DstMask is not specified. - // If DstMask is not nil, Copy will call Scale back with same dr and sr, and cause stack overflow. - if dr.Size() == sr.Size() && (opts == nil || opts.DstMask == nil) { - Copy(dst, dr.Min, src, sr, op, opts) - return - } - - var o Options - if opts != nil { - o = *opts - } - - // adr is the affected destination pixels. - adr := dst.Bounds().Intersect(dr) - adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) - if adr.Empty() || sr.Empty() { - return - } - // Make adr relative to dr.Min. - adr = adr.Sub(dr.Min) - if op == Over && o.SrcMask == nil && opaque(src) { - op = Src - } - - // sr is the source pixels. If it extends beyond the src bounds, - // we cannot use the type-specific fast paths, as they access - // the Pix fields directly without bounds checking. - // - // Similarly, the fast paths assume that the masks are nil. - if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { - switch op { - case Over: - z.scale_Image_Image_Over(dst, dr, adr, src, sr, &o) - case Src: - z.scale_Image_Image_Src(dst, dr, adr, src, sr, &o) - } - } else if _, ok := src.(*image.Uniform); ok { - Draw(dst, dr, src, src.Bounds().Min, op) - } else { - $switch z.scale_$dTypeRN_$sTypeRN$sratio_$op(dst, dr, adr, src, sr, &o) - } - } - - func (z $receiver) Transform(dst Image, s2d f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options) { - // Try to simplify a Transform to a Copy. - if s2d[0] == 1 && s2d[1] == 0 && s2d[3] == 0 && s2d[4] == 1 { - dx := int(s2d[2]) - dy := int(s2d[5]) - if float64(dx) == s2d[2] && float64(dy) == s2d[5] { - Copy(dst, image.Point{X: sr.Min.X + dx, Y: sr.Min.X + dy}, src, sr, op, opts) - return - } - } - - var o Options - if opts != nil { - o = *opts - } - - dr := transformRect(&s2d, &sr) - // adr is the affected destination pixels. - adr := dst.Bounds().Intersect(dr) - adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) - if adr.Empty() || sr.Empty() { - return - } - if op == Over && o.SrcMask == nil && opaque(src) { - op = Src - } - - d2s := invert(&s2d) - // bias is a translation of the mapping from dst coordinates to src - // coordinates such that the latter temporarily have non-negative X - // and Y coordinates. This allows us to write int(f) instead of - // int(math.Floor(f)), since "round to zero" and "round down" are - // equivalent when f >= 0, but the former is much cheaper. The X-- - // and Y-- are because the TransformLeaf methods have a "sx -= 0.5" - // adjustment. - bias := transformRect(&d2s, &adr).Min - bias.X-- - bias.Y-- - d2s[2] -= float64(bias.X) - d2s[5] -= float64(bias.Y) - // Make adr relative to dr.Min. - adr = adr.Sub(dr.Min) - // sr is the source pixels. If it extends beyond the src bounds, - // we cannot use the type-specific fast paths, as they access - // the Pix fields directly without bounds checking. - // - // Similarly, the fast paths assume that the masks are nil. - if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { - switch op { - case Over: - z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o) - case Src: - z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - } - } else if u, ok := src.(*image.Uniform); ok { - transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, op) - } else { - $switch z.transform_$dTypeRN_$sTypeRN$sratio_$op(dst, dr, adr, &d2s, src, sr, bias, &o) - } - } - ` - - codeNNScaleLeaf = ` - func (nnInterpolator) scale_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, src $sType, sr image.Rectangle, opts *Options) { - dw2 := uint64(dr.Dx()) * 2 - dh2 := uint64(dr.Dy()) * 2 - sw := uint64(sr.Dx()) - sh := uint64(sr.Dy()) - $preOuter - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * sh / dh2 - $preInner - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { $tweakDx - sx := (2*uint64(dx) + 1) * sw / dw2 - p := $srcu[sr.Min.X + int(sx), sr.Min.Y + int(sy)] - $outputu[dr.Min.X + int(dx), dr.Min.Y + int(dy), p] - } - } - } - ` - - codeNNTransformLeaf = ` - func (nnInterpolator) transform_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, d2s *f64.Aff3, src $sType, sr image.Rectangle, bias image.Point, opts *Options) { - $preOuter - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y + int(dy)) + 0.5 - $preInner - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { $tweakDx - 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 - } - p := $srcu[sx0, sy0] - $outputu[dr.Min.X + int(dx), dr.Min.Y + int(dy), p] - } - } - } - ` - - codeABLScaleLeaf = ` - func (ablInterpolator) scale_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, src $sType, sr image.Rectangle, opts *Options) { - sw := int32(sr.Dx()) - sh := int32(sr.Dy()) - yscale := float64(sh) / float64(dr.Dy()) - xscale := float64(sw) / float64(dr.Dx()) - swMinus1, shMinus1 := sw - 1, sh - 1 - $preOuter - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (float64(dy)+0.5)*yscale - 0.5 - // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if - // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for - // sx, below. - sy0 := int32(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy1 := sy0 + 1 - if sy < 0 { - sy0, sy1 = 0, 0 - yFrac0, yFrac1 = 0, 1 - } else if sy1 > shMinus1 { - sy0, sy1 = shMinus1, shMinus1 - yFrac0, yFrac1 = 1, 0 - } - $preInner - - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { $tweakDx - sx := (float64(dx)+0.5)*xscale - 0.5 - sx0 := int32(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx1 := sx0 + 1 - if sx < 0 { - sx0, sx1 = 0, 0 - xFrac0, xFrac1 = 0, 1 - } else if sx1 > swMinus1 { - sx0, sx1 = swMinus1, swMinus1 - xFrac0, xFrac1 = 1, 0 - } - - s00 := $srcf[sr.Min.X + int(sx0), sr.Min.Y + int(sy0)] - s10 := $srcf[sr.Min.X + int(sx1), sr.Min.Y + int(sy0)] - $blend[xFrac1, s00, xFrac0, s10] - s01 := $srcf[sr.Min.X + int(sx0), sr.Min.Y + int(sy1)] - s11 := $srcf[sr.Min.X + int(sx1), sr.Min.Y + int(sy1)] - $blend[xFrac1, s01, xFrac0, s11] - $blend[yFrac1, s10, yFrac0, s11] - $convFtou[p, s11] - $outputu[dr.Min.X + int(dx), dr.Min.Y + int(dy), p] - } - } - } - ` - - codeABLTransformLeaf = ` - func (ablInterpolator) transform_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, d2s *f64.Aff3, src $sType, sr image.Rectangle, bias image.Point, opts *Options) { - $preOuter - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y + int(dy)) + 0.5 - $preInner - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { $tweakDx - dxf := float64(dr.Min.X + int(dx)) + 0.5 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - sx -= 0.5 - sx0 := int(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx0 += bias.X - sx1 := sx0 + 1 - if sx0 < sr.Min.X { - sx0, sx1 = sr.Min.X, sr.Min.X - xFrac0, xFrac1 = 0, 1 - } else if sx1 >= sr.Max.X { - sx0, sx1 = sr.Max.X-1, sr.Max.X-1 - xFrac0, xFrac1 = 1, 0 - } - - sy -= 0.5 - sy0 := int(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy0 += bias.Y - sy1 := sy0 + 1 - if sy0 < sr.Min.Y { - sy0, sy1 = sr.Min.Y, sr.Min.Y - yFrac0, yFrac1 = 0, 1 - } else if sy1 >= sr.Max.Y { - sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 - yFrac0, yFrac1 = 1, 0 - } - - s00 := $srcf[sx0, sy0] - s10 := $srcf[sx1, sy0] - $blend[xFrac1, s00, xFrac0, s10] - s01 := $srcf[sx0, sy1] - s11 := $srcf[sx1, sy1] - $blend[xFrac1, s01, xFrac0, s11] - $blend[yFrac1, s10, yFrac0, s11] - $convFtou[p, s11] - $outputu[dr.Min.X + int(dx), dr.Min.Y + int(dy), p] - } - } - } - ` - - codeKernelRoot = ` - func (z *kernelScaler) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) { - if z.dw != int32(dr.Dx()) || z.dh != int32(dr.Dy()) || z.sw != int32(sr.Dx()) || z.sh != int32(sr.Dy()) { - z.kernel.Scale(dst, dr, src, sr, op, opts) - return - } - - var o Options - if opts != nil { - o = *opts - } - - // adr is the affected destination pixels. - adr := dst.Bounds().Intersect(dr) - adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) - if adr.Empty() || sr.Empty() { - return - } - // Make adr relative to dr.Min. - adr = adr.Sub(dr.Min) - if op == Over && o.SrcMask == nil && opaque(src) { - op = Src - } - - if _, ok := src.(*image.Uniform); ok && o.DstMask == nil && o.SrcMask == nil && sr.In(src.Bounds()) { - Draw(dst, dr, src, src.Bounds().Min, op) - return - } - - // Create a temporary buffer: - // scaleX distributes the source image's columns over the temporary image. - // scaleY distributes the temporary image's rows over the destination image. - var tmp [][4]float64 - if z.pool.New != nil { - tmpp := z.pool.Get().(*[][4]float64) - defer z.pool.Put(tmpp) - tmp = *tmpp - } else { - tmp = z.makeTmpBuf() - } - - // sr is the source pixels. If it extends beyond the src bounds, - // we cannot use the type-specific fast paths, as they access - // the Pix fields directly without bounds checking. - // - // Similarly, the fast paths assume that the masks are nil. - if o.SrcMask != nil || !sr.In(src.Bounds()) { - z.scaleX_Image(tmp, src, sr, &o) - } else { - $switchS z.scaleX_$sTypeRN$sratio(tmp, src, sr, &o) - } - - if o.DstMask != nil { - switch op { - case Over: - z.scaleY_Image_Over(dst, dr, adr, tmp, &o) - case Src: - z.scaleY_Image_Src(dst, dr, adr, tmp, &o) - } - } else { - $switchD z.scaleY_$dTypeRN_$op(dst, dr, adr, tmp, &o) - } - } - - func (q *Kernel) Transform(dst Image, s2d f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options) { - var o Options - if opts != nil { - o = *opts - } - - dr := transformRect(&s2d, &sr) - // adr is the affected destination pixels. - adr := dst.Bounds().Intersect(dr) - adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) - if adr.Empty() || sr.Empty() { - return - } - if op == Over && o.SrcMask == nil && opaque(src) { - op = Src - } - d2s := invert(&s2d) - // bias is a translation of the mapping from dst coordinates to src - // coordinates such that the latter temporarily have non-negative X - // and Y coordinates. This allows us to write int(f) instead of - // int(math.Floor(f)), since "round to zero" and "round down" are - // equivalent when f >= 0, but the former is much cheaper. The X-- - // and Y-- are because the TransformLeaf methods have a "sx -= 0.5" - // adjustment. - bias := transformRect(&d2s, &adr).Min - bias.X-- - bias.Y-- - d2s[2] -= float64(bias.X) - d2s[5] -= float64(bias.Y) - // Make adr relative to dr.Min. - adr = adr.Sub(dr.Min) - - if u, ok := src.(*image.Uniform); ok && o.DstMask != nil && o.SrcMask != nil && sr.In(src.Bounds()) { - transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, op) - return - } - - xscale := abs(d2s[0]) - if s := abs(d2s[1]); xscale < s { - xscale = s - } - yscale := abs(d2s[3]) - if s := abs(d2s[4]); yscale < s { - yscale = s - } - - // sr is the source pixels. If it extends beyond the src bounds, - // we cannot use the type-specific fast paths, as they access - // the Pix fields directly without bounds checking. - // - // Similarly, the fast paths assume that the masks are nil. - if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { - switch op { - case Over: - q.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - case Src: - q.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - } - } else { - $switch q.transform_$dTypeRN_$sTypeRN$sratio_$op(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - } - } - ` - - codeKernelScaleLeafX = ` - func (z *kernelScaler) scaleX_$sTypeRN$sratio(tmp [][4]float64, src $sType, sr image.Rectangle, opts *Options) { - t := 0 - $preKernelOuter - for y := int32(0); y < z.sh; y++ { - for _, s := range z.horizontal.sources { - var pr, pg, pb, pa float64 $tweakVarP - for _, c := range z.horizontal.contribs[s.i:s.j] { - p += $srcf[sr.Min.X + int(c.coord), sr.Min.Y + int(y)] * c.weight - } - $tweakPr - tmp[t] = [4]float64{ - pr * s.invTotalWeightFFFF, $tweakP - pg * s.invTotalWeightFFFF, $tweakP - pb * s.invTotalWeightFFFF, $tweakP - pa * s.invTotalWeightFFFF, $tweakP - } - t++ - } - } - } - ` - - codeKernelScaleLeafY = ` - func (z *kernelScaler) scaleY_$dTypeRN_$op(dst $dType, dr, adr image.Rectangle, tmp [][4]float64, opts *Options) { - $preOuter - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - $preKernelInner - for dy, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] { $tweakDy - var pr, pg, pb, pa float64 - for _, c := range z.vertical.contribs[s.i:s.j] { - p := &tmp[c.coord*z.dw+dx] - pr += p[0] * c.weight - pg += p[1] * c.weight - pb += p[2] * c.weight - pa += p[3] * c.weight - } - $clampToAlpha - $outputf[dr.Min.X + int(dx), dr.Min.Y + int(adr.Min.Y + dy), ftou, p, s.invTotalWeight] - $tweakD - } - } - } - ` - - codeKernelTransformLeaf = ` - func (q *Kernel) transform_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, d2s *f64.Aff3, src $sType, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { - // When shrinking, broaden the effective kernel support so that we still - // visit every source pixel. - xHalfWidth, xKernelArgScale := q.Support, 1.0 - if xscale > 1 { - xHalfWidth *= xscale - xKernelArgScale = 1 / xscale - } - yHalfWidth, yKernelArgScale := q.Support, 1.0 - if yscale > 1 { - yHalfWidth *= yscale - yKernelArgScale = 1 / yscale - } - - xWeights := make([]float64, 1 + 2*int(math.Ceil(xHalfWidth))) - yWeights := make([]float64, 1 + 2*int(math.Ceil(yHalfWidth))) - - $preOuter - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y + int(dy)) + 0.5 - $preInner - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { $tweakDx - dxf := float64(dr.Min.X + int(dx)) + 0.5 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - // TODO: adjust the bias so that we can use int(f) instead - // of math.Floor(f) and math.Ceil(f). - sx += float64(bias.X) - sx -= 0.5 - ix := int(math.Floor(sx - xHalfWidth)) - if ix < sr.Min.X { - ix = sr.Min.X - } - jx := int(math.Ceil(sx + xHalfWidth)) - if jx > sr.Max.X { - jx = sr.Max.X - } - - totalXWeight := 0.0 - for kx := ix; kx < jx; kx++ { - xWeight := 0.0 - if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { - xWeight = q.At(t) - } - xWeights[kx - ix] = xWeight - totalXWeight += xWeight - } - for x := range xWeights[:jx-ix] { - xWeights[x] /= totalXWeight - } - - sy += float64(bias.Y) - sy -= 0.5 - iy := int(math.Floor(sy - yHalfWidth)) - if iy < sr.Min.Y { - iy = sr.Min.Y - } - jy := int(math.Ceil(sy + yHalfWidth)) - if jy > sr.Max.Y { - jy = sr.Max.Y - } - - totalYWeight := 0.0 - for ky := iy; ky < jy; ky++ { - yWeight := 0.0 - if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { - yWeight = q.At(t) - } - yWeights[ky - iy] = yWeight - totalYWeight += yWeight - } - for y := range yWeights[:jy-iy] { - yWeights[y] /= totalYWeight - } - - var pr, pg, pb, pa float64 $tweakVarP - for ky := iy; ky < jy; ky++ { - if yWeight := yWeights[ky - iy]; yWeight != 0 { - for kx := ix; kx < jx; kx++ { - if w := xWeights[kx - ix] * yWeight; w != 0 { - p += $srcf[kx, ky] * w - } - } - } - } - $clampToAlpha - $outputf[dr.Min.X + int(dx), dr.Min.Y + int(dy), fffftou, p, 1] - } - } - } - ` -) diff --git a/vendor/golang.org/x/image/draw/go1_8.go b/vendor/golang.org/x/image/draw/go1_8.go deleted file mode 100644 index ec192b7..0000000 --- a/vendor/golang.org/x/image/draw/go1_8.go +++ /dev/null @@ -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 -} diff --git a/vendor/golang.org/x/image/draw/go1_9.go b/vendor/golang.org/x/image/draw/go1_9.go deleted file mode 100644 index fc548e9..0000000 --- a/vendor/golang.org/x/image/draw/go1_9.go +++ /dev/null @@ -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 diff --git a/vendor/golang.org/x/image/draw/impl.go b/vendor/golang.org/x/image/draw/impl.go deleted file mode 100644 index 75498ad..0000000 --- a/vendor/golang.org/x/image/draw/impl.go +++ /dev/null @@ -1,6670 +0,0 @@ -// generated by "go run gen.go". DO NOT EDIT. - -package draw - -import ( - "image" - "image/color" - "math" - - "golang.org/x/image/math/f64" -) - -func (z nnInterpolator) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) { - // Try to simplify a Scale to a Copy when DstMask is not specified. - // If DstMask is not nil, Copy will call Scale back with same dr and sr, and cause stack overflow. - if dr.Size() == sr.Size() && (opts == nil || opts.DstMask == nil) { - Copy(dst, dr.Min, src, sr, op, opts) - return - } - - var o Options - if opts != nil { - o = *opts - } - - // adr is the affected destination pixels. - adr := dst.Bounds().Intersect(dr) - adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) - if adr.Empty() || sr.Empty() { - return - } - // Make adr relative to dr.Min. - adr = adr.Sub(dr.Min) - if op == Over && o.SrcMask == nil && opaque(src) { - op = Src - } - - // sr is the source pixels. If it extends beyond the src bounds, - // we cannot use the type-specific fast paths, as they access - // the Pix fields directly without bounds checking. - // - // Similarly, the fast paths assume that the masks are nil. - if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { - switch op { - case Over: - z.scale_Image_Image_Over(dst, dr, adr, src, sr, &o) - case Src: - z.scale_Image_Image_Src(dst, dr, adr, src, sr, &o) - } - } else if _, ok := src.(*image.Uniform); ok { - Draw(dst, dr, src, src.Bounds().Min, op) - } else { - switch op { - case Over: - switch dst := dst.(type) { - case *image.RGBA: - switch src := src.(type) { - case *image.NRGBA: - z.scale_RGBA_NRGBA_Over(dst, dr, adr, src, sr, &o) - case *image.RGBA: - z.scale_RGBA_RGBA_Over(dst, dr, adr, src, sr, &o) - default: - z.scale_RGBA_Image_Over(dst, dr, adr, src, sr, &o) - } - default: - switch src := src.(type) { - default: - z.scale_Image_Image_Over(dst, dr, adr, src, sr, &o) - } - } - case Src: - switch dst := dst.(type) { - case *image.RGBA: - switch src := src.(type) { - case *image.Gray: - z.scale_RGBA_Gray_Src(dst, dr, adr, src, sr, &o) - case *image.NRGBA: - z.scale_RGBA_NRGBA_Src(dst, dr, adr, src, sr, &o) - case *image.RGBA: - z.scale_RGBA_RGBA_Src(dst, dr, adr, src, sr, &o) - case *image.YCbCr: - switch src.SubsampleRatio { - default: - z.scale_RGBA_Image_Src(dst, dr, adr, src, sr, &o) - case image.YCbCrSubsampleRatio444: - z.scale_RGBA_YCbCr444_Src(dst, dr, adr, src, sr, &o) - case image.YCbCrSubsampleRatio422: - z.scale_RGBA_YCbCr422_Src(dst, dr, adr, src, sr, &o) - case image.YCbCrSubsampleRatio420: - z.scale_RGBA_YCbCr420_Src(dst, dr, adr, src, sr, &o) - case image.YCbCrSubsampleRatio440: - z.scale_RGBA_YCbCr440_Src(dst, dr, adr, src, sr, &o) - } - default: - z.scale_RGBA_Image_Src(dst, dr, adr, src, sr, &o) - } - default: - switch src := src.(type) { - default: - z.scale_Image_Image_Src(dst, dr, adr, src, sr, &o) - } - } - } - } -} - -func (z nnInterpolator) Transform(dst Image, s2d f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options) { - // Try to simplify a Transform to a Copy. - if s2d[0] == 1 && s2d[1] == 0 && s2d[3] == 0 && s2d[4] == 1 { - dx := int(s2d[2]) - dy := int(s2d[5]) - if float64(dx) == s2d[2] && float64(dy) == s2d[5] { - Copy(dst, image.Point{X: sr.Min.X + dx, Y: sr.Min.X + dy}, src, sr, op, opts) - return - } - } - - var o Options - if opts != nil { - o = *opts - } - - dr := transformRect(&s2d, &sr) - // adr is the affected destination pixels. - adr := dst.Bounds().Intersect(dr) - adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) - if adr.Empty() || sr.Empty() { - return - } - if op == Over && o.SrcMask == nil && opaque(src) { - op = Src - } - - d2s := invert(&s2d) - // bias is a translation of the mapping from dst coordinates to src - // coordinates such that the latter temporarily have non-negative X - // and Y coordinates. This allows us to write int(f) instead of - // int(math.Floor(f)), since "round to zero" and "round down" are - // equivalent when f >= 0, but the former is much cheaper. The X-- - // and Y-- are because the TransformLeaf methods have a "sx -= 0.5" - // adjustment. - bias := transformRect(&d2s, &adr).Min - bias.X-- - bias.Y-- - d2s[2] -= float64(bias.X) - d2s[5] -= float64(bias.Y) - // Make adr relative to dr.Min. - adr = adr.Sub(dr.Min) - // sr is the source pixels. If it extends beyond the src bounds, - // we cannot use the type-specific fast paths, as they access - // the Pix fields directly without bounds checking. - // - // Similarly, the fast paths assume that the masks are nil. - if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { - switch op { - case Over: - z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o) - case Src: - z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - } - } else if u, ok := src.(*image.Uniform); ok { - transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, op) - } else { - switch op { - case Over: - switch dst := dst.(type) { - case *image.RGBA: - switch src := src.(type) { - case *image.NRGBA: - z.transform_RGBA_NRGBA_Over(dst, dr, adr, &d2s, src, sr, bias, &o) - case *image.RGBA: - z.transform_RGBA_RGBA_Over(dst, dr, adr, &d2s, src, sr, bias, &o) - default: - z.transform_RGBA_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o) - } - default: - switch src := src.(type) { - default: - z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o) - } - } - case Src: - switch dst := dst.(type) { - case *image.RGBA: - switch src := src.(type) { - case *image.Gray: - z.transform_RGBA_Gray_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - case *image.NRGBA: - z.transform_RGBA_NRGBA_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - case *image.RGBA: - z.transform_RGBA_RGBA_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - case *image.YCbCr: - switch src.SubsampleRatio { - default: - z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - case image.YCbCrSubsampleRatio444: - z.transform_RGBA_YCbCr444_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - case image.YCbCrSubsampleRatio422: - z.transform_RGBA_YCbCr422_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - case image.YCbCrSubsampleRatio420: - z.transform_RGBA_YCbCr420_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - case image.YCbCrSubsampleRatio440: - z.transform_RGBA_YCbCr440_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - } - default: - z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - } - default: - switch src := src.(type) { - default: - z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - } - } - } - } -} - -func (nnInterpolator) scale_RGBA_Gray_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.Gray, sr image.Rectangle, opts *Options) { - dw2 := uint64(dr.Dx()) * 2 - dh2 := uint64(dr.Dy()) * 2 - sw := uint64(sr.Dx()) - sh := uint64(sr.Dy()) - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * sh / dh2 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (2*uint64(dx) + 1) * sw / dw2 - pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx) - src.Rect.Min.X) - pr := uint32(src.Pix[pi]) * 0x101 - out := uint8(pr >> 8) - dst.Pix[d+0] = out - dst.Pix[d+1] = out - dst.Pix[d+2] = out - dst.Pix[d+3] = 0xff - } - } -} - -func (nnInterpolator) scale_RGBA_NRGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle, opts *Options) { - dw2 := uint64(dr.Dx()) * 2 - dh2 := uint64(dr.Dy()) * 2 - sw := uint64(sr.Dx()) - sh := uint64(sr.Dy()) - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * sh / dh2 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (2*uint64(dx) + 1) * sw / dw2 - pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx)-src.Rect.Min.X)*4 - pa := uint32(src.Pix[pi+3]) * 0x101 - pr := uint32(src.Pix[pi+0]) * pa / 0xff - pg := uint32(src.Pix[pi+1]) * pa / 0xff - pb := uint32(src.Pix[pi+2]) * pa / 0xff - pa1 := (0xffff - pa) * 0x101 - 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) - } - } -} - -func (nnInterpolator) scale_RGBA_NRGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle, opts *Options) { - dw2 := uint64(dr.Dx()) * 2 - dh2 := uint64(dr.Dy()) * 2 - sw := uint64(sr.Dx()) - sh := uint64(sr.Dy()) - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * sh / dh2 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (2*uint64(dx) + 1) * sw / dw2 - pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx)-src.Rect.Min.X)*4 - pa := uint32(src.Pix[pi+3]) * 0x101 - pr := uint32(src.Pix[pi+0]) * pa / 0xff - pg := uint32(src.Pix[pi+1]) * pa / 0xff - pb := uint32(src.Pix[pi+2]) * pa / 0xff - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = uint8(pa >> 8) - } - } -} - -func (nnInterpolator) scale_RGBA_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle, opts *Options) { - dw2 := uint64(dr.Dx()) * 2 - dh2 := uint64(dr.Dy()) * 2 - sw := uint64(sr.Dx()) - sh := uint64(sr.Dy()) - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * sh / dh2 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (2*uint64(dx) + 1) * sw / dw2 - pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx)-src.Rect.Min.X)*4 - pr := uint32(src.Pix[pi+0]) * 0x101 - pg := uint32(src.Pix[pi+1]) * 0x101 - pb := uint32(src.Pix[pi+2]) * 0x101 - pa := uint32(src.Pix[pi+3]) * 0x101 - pa1 := (0xffff - pa) * 0x101 - 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) - } - } -} - -func (nnInterpolator) scale_RGBA_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle, opts *Options) { - dw2 := uint64(dr.Dx()) * 2 - dh2 := uint64(dr.Dy()) * 2 - sw := uint64(sr.Dx()) - sh := uint64(sr.Dy()) - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * sh / dh2 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (2*uint64(dx) + 1) * sw / dw2 - pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx)-src.Rect.Min.X)*4 - pr := uint32(src.Pix[pi+0]) * 0x101 - pg := uint32(src.Pix[pi+1]) * 0x101 - pb := uint32(src.Pix[pi+2]) * 0x101 - pa := uint32(src.Pix[pi+3]) * 0x101 - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = uint8(pa >> 8) - } - } -} - -func (nnInterpolator) scale_RGBA_YCbCr444_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { - dw2 := uint64(dr.Dx()) * 2 - dh2 := uint64(dr.Dy()) * 2 - sw := uint64(sr.Dx()) - sh := uint64(sr.Dy()) - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * sh / dh2 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (2*uint64(dx) + 1) * sw / dw2 - pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx) - src.Rect.Min.X) - pj := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.CStride + (sr.Min.X + int(sx) - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pr := (pyy1 + 91881*pcr1) >> 8 - pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pb := (pyy1 + 116130*pcb1) >> 8 - if pr < 0 { - pr = 0 - } else if pr > 0xffff { - pr = 0xffff - } - if pg < 0 { - pg = 0 - } else if pg > 0xffff { - pg = 0xffff - } - if pb < 0 { - pb = 0 - } else if pb > 0xffff { - pb = 0xffff - } - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (nnInterpolator) scale_RGBA_YCbCr422_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { - dw2 := uint64(dr.Dx()) * 2 - dh2 := uint64(dr.Dy()) * 2 - sw := uint64(sr.Dx()) - sh := uint64(sr.Dy()) - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * sh / dh2 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (2*uint64(dx) + 1) * sw / dw2 - pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx) - src.Rect.Min.X) - pj := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.CStride + ((sr.Min.X+int(sx))/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pr := (pyy1 + 91881*pcr1) >> 8 - pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pb := (pyy1 + 116130*pcb1) >> 8 - if pr < 0 { - pr = 0 - } else if pr > 0xffff { - pr = 0xffff - } - if pg < 0 { - pg = 0 - } else if pg > 0xffff { - pg = 0xffff - } - if pb < 0 { - pb = 0 - } else if pb > 0xffff { - pb = 0xffff - } - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (nnInterpolator) scale_RGBA_YCbCr420_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { - dw2 := uint64(dr.Dx()) * 2 - dh2 := uint64(dr.Dy()) * 2 - sw := uint64(sr.Dx()) - sh := uint64(sr.Dy()) - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * sh / dh2 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (2*uint64(dx) + 1) * sw / dw2 - pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx) - src.Rect.Min.X) - pj := ((sr.Min.Y+int(sy))/2-src.Rect.Min.Y/2)*src.CStride + ((sr.Min.X+int(sx))/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pr := (pyy1 + 91881*pcr1) >> 8 - pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pb := (pyy1 + 116130*pcb1) >> 8 - if pr < 0 { - pr = 0 - } else if pr > 0xffff { - pr = 0xffff - } - if pg < 0 { - pg = 0 - } else if pg > 0xffff { - pg = 0xffff - } - if pb < 0 { - pb = 0 - } else if pb > 0xffff { - pb = 0xffff - } - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (nnInterpolator) scale_RGBA_YCbCr440_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { - dw2 := uint64(dr.Dx()) * 2 - dh2 := uint64(dr.Dy()) * 2 - sw := uint64(sr.Dx()) - sh := uint64(sr.Dy()) - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * sh / dh2 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (2*uint64(dx) + 1) * sw / dw2 - pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx) - src.Rect.Min.X) - pj := ((sr.Min.Y+int(sy))/2-src.Rect.Min.Y/2)*src.CStride + (sr.Min.X + int(sx) - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pr := (pyy1 + 91881*pcr1) >> 8 - pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pb := (pyy1 + 116130*pcb1) >> 8 - if pr < 0 { - pr = 0 - } else if pr > 0xffff { - pr = 0xffff - } - if pg < 0 { - pg = 0 - } else if pg > 0xffff { - pg = 0xffff - } - if pb < 0 { - pb = 0 - } else if pb > 0xffff { - pb = 0xffff - } - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (nnInterpolator) scale_RGBA_Image_Over(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { - dw2 := uint64(dr.Dx()) * 2 - dh2 := uint64(dr.Dy()) * 2 - sw := uint64(sr.Dx()) - sh := uint64(sr.Dy()) - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * sh / dh2 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (2*uint64(dx) + 1) * sw / dw2 - pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA() - pa1 := (0xffff - pa) * 0x101 - 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) - } - } -} - -func (nnInterpolator) scale_RGBA_Image_Src(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { - dw2 := uint64(dr.Dx()) * 2 - dh2 := uint64(dr.Dy()) * 2 - sw := uint64(sr.Dx()) - sh := uint64(sr.Dy()) - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * sh / dh2 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (2*uint64(dx) + 1) * sw / dw2 - pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA() - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = uint8(pa >> 8) - } - } -} - -func (nnInterpolator) scale_Image_Image_Over(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { - dw2 := uint64(dr.Dx()) * 2 - dh2 := uint64(dr.Dy()) * 2 - sw := uint64(sr.Dx()) - sh := uint64(sr.Dy()) - srcMask, smp := opts.SrcMask, opts.SrcMaskP - dstMask, dmp := opts.DstMask, opts.DstMaskP - dstColorRGBA64 := &color.RGBA64{} - dstColor := color.Color(dstColorRGBA64) - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * sh / dh2 - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - sx := (2*uint64(dx) + 1) * sw / dw2 - pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx), smp.Y+sr.Min.Y+int(sy)).RGBA() - pr = pr * ma / 0xffff - pg = pg * ma / 0xffff - pb = pb * ma / 0xffff - pa = pa * ma / 0xffff - } - qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() - if dstMask != nil { - _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() - pr = pr * ma / 0xffff - pg = pg * ma / 0xffff - pb = pb * ma / 0xffff - pa = pa * ma / 0xffff - } - pa1 := 0xffff - pa - 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) - } - } -} - -func (nnInterpolator) scale_Image_Image_Src(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { - dw2 := uint64(dr.Dx()) * 2 - dh2 := uint64(dr.Dy()) * 2 - sw := uint64(sr.Dx()) - sh := uint64(sr.Dy()) - srcMask, smp := opts.SrcMask, opts.SrcMaskP - dstMask, dmp := opts.DstMask, opts.DstMaskP - dstColorRGBA64 := &color.RGBA64{} - dstColor := color.Color(dstColorRGBA64) - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (2*uint64(dy) + 1) * sh / dh2 - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - sx := (2*uint64(dx) + 1) * sw / dw2 - pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx), smp.Y+sr.Min.Y+int(sy)).RGBA() - pr = pr * ma / 0xffff - pg = pg * ma / 0xffff - pb = pb * ma / 0xffff - pa = pa * ma / 0xffff - } - if dstMask != nil { - qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() - _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() - pr = pr * ma / 0xffff - pg = pg * ma / 0xffff - pb = pb * ma / 0xffff - pa = pa * ma / 0xffff - pa1 := 0xffff - ma - 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) - } else { - dstColorRGBA64.R = uint16(pr) - dstColorRGBA64.G = uint16(pg) - dstColorRGBA64.B = uint16(pb) - dstColorRGBA64.A = uint16(pa) - dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) - } - } - } -} - -func (nnInterpolator) transform_RGBA_Gray_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Gray, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - } - pi := (sy0-src.Rect.Min.Y)*src.Stride + (sx0 - src.Rect.Min.X) - pr := uint32(src.Pix[pi]) * 0x101 - out := uint8(pr >> 8) - dst.Pix[d+0] = out - dst.Pix[d+1] = out - dst.Pix[d+2] = out - dst.Pix[d+3] = 0xff - } - } -} - -func (nnInterpolator) transform_RGBA_NRGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - } - pi := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 - pa := uint32(src.Pix[pi+3]) * 0x101 - pr := uint32(src.Pix[pi+0]) * pa / 0xff - pg := uint32(src.Pix[pi+1]) * pa / 0xff - pb := uint32(src.Pix[pi+2]) * pa / 0xff - pa1 := (0xffff - pa) * 0x101 - 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) - } - } -} - -func (nnInterpolator) transform_RGBA_NRGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - } - pi := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 - pa := uint32(src.Pix[pi+3]) * 0x101 - pr := uint32(src.Pix[pi+0]) * pa / 0xff - pg := uint32(src.Pix[pi+1]) * pa / 0xff - pb := uint32(src.Pix[pi+2]) * pa / 0xff - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = uint8(pa >> 8) - } - } -} - -func (nnInterpolator) transform_RGBA_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - } - pi := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 - pr := uint32(src.Pix[pi+0]) * 0x101 - pg := uint32(src.Pix[pi+1]) * 0x101 - pb := uint32(src.Pix[pi+2]) * 0x101 - pa := uint32(src.Pix[pi+3]) * 0x101 - pa1 := (0xffff - pa) * 0x101 - 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) - } - } -} - -func (nnInterpolator) transform_RGBA_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - } - pi := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 - pr := uint32(src.Pix[pi+0]) * 0x101 - pg := uint32(src.Pix[pi+1]) * 0x101 - pb := uint32(src.Pix[pi+2]) * 0x101 - pa := uint32(src.Pix[pi+3]) * 0x101 - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = uint8(pa >> 8) - } - } -} - -func (nnInterpolator) transform_RGBA_YCbCr444_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - } - pi := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) - pj := (sy0-src.Rect.Min.Y)*src.CStride + (sx0 - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pr := (pyy1 + 91881*pcr1) >> 8 - pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pb := (pyy1 + 116130*pcb1) >> 8 - if pr < 0 { - pr = 0 - } else if pr > 0xffff { - pr = 0xffff - } - if pg < 0 { - pg = 0 - } else if pg > 0xffff { - pg = 0xffff - } - if pb < 0 { - pb = 0 - } else if pb > 0xffff { - pb = 0xffff - } - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (nnInterpolator) transform_RGBA_YCbCr422_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - } - pi := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) - pj := (sy0-src.Rect.Min.Y)*src.CStride + ((sx0)/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pr := (pyy1 + 91881*pcr1) >> 8 - pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pb := (pyy1 + 116130*pcb1) >> 8 - if pr < 0 { - pr = 0 - } else if pr > 0xffff { - pr = 0xffff - } - if pg < 0 { - pg = 0 - } else if pg > 0xffff { - pg = 0xffff - } - if pb < 0 { - pb = 0 - } else if pb > 0xffff { - pb = 0xffff - } - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (nnInterpolator) transform_RGBA_YCbCr420_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - } - pi := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) - pj := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + ((sx0)/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pr := (pyy1 + 91881*pcr1) >> 8 - pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pb := (pyy1 + 116130*pcb1) >> 8 - if pr < 0 { - pr = 0 - } else if pr > 0xffff { - pr = 0xffff - } - if pg < 0 { - pg = 0 - } else if pg > 0xffff { - pg = 0xffff - } - if pb < 0 { - pb = 0 - } else if pb > 0xffff { - pb = 0xffff - } - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (nnInterpolator) transform_RGBA_YCbCr440_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - } - pi := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) - pj := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + (sx0 - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pr := (pyy1 + 91881*pcr1) >> 8 - pg := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pb := (pyy1 + 116130*pcb1) >> 8 - if pr < 0 { - pr = 0 - } else if pr > 0xffff { - pr = 0xffff - } - if pg < 0 { - pg = 0 - } else if pg > 0xffff { - pg = 0xffff - } - if pb < 0 { - pb = 0 - } else if pb > 0xffff { - pb = 0xffff - } - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (nnInterpolator) transform_RGBA_Image_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - } - pr, pg, pb, pa := src.At(sx0, sy0).RGBA() - pa1 := (0xffff - pa) * 0x101 - 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) - } - } -} - -func (nnInterpolator) transform_RGBA_Image_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - } - pr, pg, pb, pa := src.At(sx0, sy0).RGBA() - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = uint8(pa >> 8) - } - } -} - -func (nnInterpolator) transform_Image_Image_Over(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { - srcMask, smp := opts.SrcMask, opts.SrcMaskP - dstMask, dmp := opts.DstMask, opts.DstMaskP - 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 - } - pr, pg, pb, pa := src.At(sx0, sy0).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sx0, smp.Y+sy0).RGBA() - pr = pr * ma / 0xffff - pg = pg * ma / 0xffff - pb = pb * ma / 0xffff - pa = pa * ma / 0xffff - } - qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() - if dstMask != nil { - _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() - pr = pr * ma / 0xffff - pg = pg * ma / 0xffff - pb = pb * ma / 0xffff - pa = pa * ma / 0xffff - } - pa1 := 0xffff - pa - 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) - } - } -} - -func (nnInterpolator) transform_Image_Image_Src(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { - srcMask, smp := opts.SrcMask, opts.SrcMaskP - dstMask, dmp := opts.DstMask, opts.DstMaskP - 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 - } - pr, pg, pb, pa := src.At(sx0, sy0).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sx0, smp.Y+sy0).RGBA() - pr = pr * ma / 0xffff - pg = pg * ma / 0xffff - pb = pb * ma / 0xffff - pa = pa * ma / 0xffff - } - if dstMask != nil { - qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() - _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() - pr = pr * ma / 0xffff - pg = pg * ma / 0xffff - pb = pb * ma / 0xffff - pa = pa * ma / 0xffff - pa1 := 0xffff - ma - 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) - } else { - dstColorRGBA64.R = uint16(pr) - dstColorRGBA64.G = uint16(pg) - dstColorRGBA64.B = uint16(pb) - dstColorRGBA64.A = uint16(pa) - dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) - } - } - } -} - -func (z ablInterpolator) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) { - // Try to simplify a Scale to a Copy when DstMask is not specified. - // If DstMask is not nil, Copy will call Scale back with same dr and sr, and cause stack overflow. - if dr.Size() == sr.Size() && (opts == nil || opts.DstMask == nil) { - Copy(dst, dr.Min, src, sr, op, opts) - return - } - - var o Options - if opts != nil { - o = *opts - } - - // adr is the affected destination pixels. - adr := dst.Bounds().Intersect(dr) - adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) - if adr.Empty() || sr.Empty() { - return - } - // Make adr relative to dr.Min. - adr = adr.Sub(dr.Min) - if op == Over && o.SrcMask == nil && opaque(src) { - op = Src - } - - // sr is the source pixels. If it extends beyond the src bounds, - // we cannot use the type-specific fast paths, as they access - // the Pix fields directly without bounds checking. - // - // Similarly, the fast paths assume that the masks are nil. - if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { - switch op { - case Over: - z.scale_Image_Image_Over(dst, dr, adr, src, sr, &o) - case Src: - z.scale_Image_Image_Src(dst, dr, adr, src, sr, &o) - } - } else if _, ok := src.(*image.Uniform); ok { - Draw(dst, dr, src, src.Bounds().Min, op) - } else { - switch op { - case Over: - switch dst := dst.(type) { - case *image.RGBA: - switch src := src.(type) { - case *image.NRGBA: - z.scale_RGBA_NRGBA_Over(dst, dr, adr, src, sr, &o) - case *image.RGBA: - z.scale_RGBA_RGBA_Over(dst, dr, adr, src, sr, &o) - default: - z.scale_RGBA_Image_Over(dst, dr, adr, src, sr, &o) - } - default: - switch src := src.(type) { - default: - z.scale_Image_Image_Over(dst, dr, adr, src, sr, &o) - } - } - case Src: - switch dst := dst.(type) { - case *image.RGBA: - switch src := src.(type) { - case *image.Gray: - z.scale_RGBA_Gray_Src(dst, dr, adr, src, sr, &o) - case *image.NRGBA: - z.scale_RGBA_NRGBA_Src(dst, dr, adr, src, sr, &o) - case *image.RGBA: - z.scale_RGBA_RGBA_Src(dst, dr, adr, src, sr, &o) - case *image.YCbCr: - switch src.SubsampleRatio { - default: - z.scale_RGBA_Image_Src(dst, dr, adr, src, sr, &o) - case image.YCbCrSubsampleRatio444: - z.scale_RGBA_YCbCr444_Src(dst, dr, adr, src, sr, &o) - case image.YCbCrSubsampleRatio422: - z.scale_RGBA_YCbCr422_Src(dst, dr, adr, src, sr, &o) - case image.YCbCrSubsampleRatio420: - z.scale_RGBA_YCbCr420_Src(dst, dr, adr, src, sr, &o) - case image.YCbCrSubsampleRatio440: - z.scale_RGBA_YCbCr440_Src(dst, dr, adr, src, sr, &o) - } - default: - z.scale_RGBA_Image_Src(dst, dr, adr, src, sr, &o) - } - default: - switch src := src.(type) { - default: - z.scale_Image_Image_Src(dst, dr, adr, src, sr, &o) - } - } - } - } -} - -func (z ablInterpolator) Transform(dst Image, s2d f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options) { - // Try to simplify a Transform to a Copy. - if s2d[0] == 1 && s2d[1] == 0 && s2d[3] == 0 && s2d[4] == 1 { - dx := int(s2d[2]) - dy := int(s2d[5]) - if float64(dx) == s2d[2] && float64(dy) == s2d[5] { - Copy(dst, image.Point{X: sr.Min.X + dx, Y: sr.Min.X + dy}, src, sr, op, opts) - return - } - } - - var o Options - if opts != nil { - o = *opts - } - - dr := transformRect(&s2d, &sr) - // adr is the affected destination pixels. - adr := dst.Bounds().Intersect(dr) - adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) - if adr.Empty() || sr.Empty() { - return - } - if op == Over && o.SrcMask == nil && opaque(src) { - op = Src - } - - d2s := invert(&s2d) - // bias is a translation of the mapping from dst coordinates to src - // coordinates such that the latter temporarily have non-negative X - // and Y coordinates. This allows us to write int(f) instead of - // int(math.Floor(f)), since "round to zero" and "round down" are - // equivalent when f >= 0, but the former is much cheaper. The X-- - // and Y-- are because the TransformLeaf methods have a "sx -= 0.5" - // adjustment. - bias := transformRect(&d2s, &adr).Min - bias.X-- - bias.Y-- - d2s[2] -= float64(bias.X) - d2s[5] -= float64(bias.Y) - // Make adr relative to dr.Min. - adr = adr.Sub(dr.Min) - // sr is the source pixels. If it extends beyond the src bounds, - // we cannot use the type-specific fast paths, as they access - // the Pix fields directly without bounds checking. - // - // Similarly, the fast paths assume that the masks are nil. - if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { - switch op { - case Over: - z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o) - case Src: - z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - } - } else if u, ok := src.(*image.Uniform); ok { - transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, op) - } else { - switch op { - case Over: - switch dst := dst.(type) { - case *image.RGBA: - switch src := src.(type) { - case *image.NRGBA: - z.transform_RGBA_NRGBA_Over(dst, dr, adr, &d2s, src, sr, bias, &o) - case *image.RGBA: - z.transform_RGBA_RGBA_Over(dst, dr, adr, &d2s, src, sr, bias, &o) - default: - z.transform_RGBA_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o) - } - default: - switch src := src.(type) { - default: - z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o) - } - } - case Src: - switch dst := dst.(type) { - case *image.RGBA: - switch src := src.(type) { - case *image.Gray: - z.transform_RGBA_Gray_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - case *image.NRGBA: - z.transform_RGBA_NRGBA_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - case *image.RGBA: - z.transform_RGBA_RGBA_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - case *image.YCbCr: - switch src.SubsampleRatio { - default: - z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - case image.YCbCrSubsampleRatio444: - z.transform_RGBA_YCbCr444_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - case image.YCbCrSubsampleRatio422: - z.transform_RGBA_YCbCr422_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - case image.YCbCrSubsampleRatio420: - z.transform_RGBA_YCbCr420_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - case image.YCbCrSubsampleRatio440: - z.transform_RGBA_YCbCr440_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - } - default: - z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - } - default: - switch src := src.(type) { - default: - z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o) - } - } - } - } -} - -func (ablInterpolator) scale_RGBA_Gray_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.Gray, sr image.Rectangle, opts *Options) { - sw := int32(sr.Dx()) - sh := int32(sr.Dy()) - yscale := float64(sh) / float64(dr.Dy()) - xscale := float64(sw) / float64(dr.Dx()) - swMinus1, shMinus1 := sw-1, sh-1 - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (float64(dy)+0.5)*yscale - 0.5 - // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if - // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for - // sx, below. - sy0 := int32(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy1 := sy0 + 1 - if sy < 0 { - sy0, sy1 = 0, 0 - yFrac0, yFrac1 = 0, 1 - } else if sy1 > shMinus1 { - sy0, sy1 = shMinus1, shMinus1 - yFrac0, yFrac1 = 1, 0 - } - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (float64(dx)+0.5)*xscale - 0.5 - sx0 := int32(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx1 := sx0 + 1 - if sx < 0 { - sx0, sx1 = 0, 0 - xFrac0, xFrac1 = 0, 1 - } else if sx1 > swMinus1 { - sx0, sx1 = swMinus1, swMinus1 - xFrac0, xFrac1 = 1, 0 - } - - s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx0) - src.Rect.Min.X) - s00ru := uint32(src.Pix[s00i]) * 0x101 - s00r := float64(s00ru) - s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx1) - src.Rect.Min.X) - s10ru := uint32(src.Pix[s10i]) * 0x101 - s10r := float64(s10ru) - s10r = xFrac1*s00r + xFrac0*s10r - s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx0) - src.Rect.Min.X) - s01ru := uint32(src.Pix[s01i]) * 0x101 - s01r := float64(s01ru) - s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx1) - src.Rect.Min.X) - s11ru := uint32(src.Pix[s11i]) * 0x101 - s11r := float64(s11ru) - s11r = xFrac1*s01r + xFrac0*s11r - s11r = yFrac1*s10r + yFrac0*s11r - pr := uint32(s11r) - out := uint8(pr >> 8) - dst.Pix[d+0] = out - dst.Pix[d+1] = out - dst.Pix[d+2] = out - dst.Pix[d+3] = 0xff - } - } -} - -func (ablInterpolator) scale_RGBA_NRGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle, opts *Options) { - sw := int32(sr.Dx()) - sh := int32(sr.Dy()) - yscale := float64(sh) / float64(dr.Dy()) - xscale := float64(sw) / float64(dr.Dx()) - swMinus1, shMinus1 := sw-1, sh-1 - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (float64(dy)+0.5)*yscale - 0.5 - // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if - // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for - // sx, below. - sy0 := int32(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy1 := sy0 + 1 - if sy < 0 { - sy0, sy1 = 0, 0 - yFrac0, yFrac1 = 0, 1 - } else if sy1 > shMinus1 { - sy0, sy1 = shMinus1, shMinus1 - yFrac0, yFrac1 = 1, 0 - } - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (float64(dx)+0.5)*xscale - 0.5 - sx0 := int32(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx1 := sx0 + 1 - if sx < 0 { - sx0, sx1 = 0, 0 - xFrac0, xFrac1 = 0, 1 - } else if sx1 > swMinus1 { - sx0, sx1 = swMinus1, swMinus1 - xFrac0, xFrac1 = 1, 0 - } - - s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 - s00au := uint32(src.Pix[s00i+3]) * 0x101 - s00ru := uint32(src.Pix[s00i+0]) * s00au / 0xff - s00gu := uint32(src.Pix[s00i+1]) * s00au / 0xff - s00bu := uint32(src.Pix[s00i+2]) * s00au / 0xff - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 - s10au := uint32(src.Pix[s10i+3]) * 0x101 - s10ru := uint32(src.Pix[s10i+0]) * s10au / 0xff - s10gu := uint32(src.Pix[s10i+1]) * s10au / 0xff - s10bu := uint32(src.Pix[s10i+2]) * s10au / 0xff - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 - s01au := uint32(src.Pix[s01i+3]) * 0x101 - s01ru := uint32(src.Pix[s01i+0]) * s01au / 0xff - s01gu := uint32(src.Pix[s01i+1]) * s01au / 0xff - s01bu := uint32(src.Pix[s01i+2]) * s01au / 0xff - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 - s11au := uint32(src.Pix[s11i+3]) * 0x101 - s11ru := uint32(src.Pix[s11i+0]) * s11au / 0xff - s11gu := uint32(src.Pix[s11i+1]) * s11au / 0xff - s11bu := uint32(src.Pix[s11i+2]) * s11au / 0xff - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - pa1 := (0xffff - pa) * 0x101 - 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) - } - } -} - -func (ablInterpolator) scale_RGBA_NRGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle, opts *Options) { - sw := int32(sr.Dx()) - sh := int32(sr.Dy()) - yscale := float64(sh) / float64(dr.Dy()) - xscale := float64(sw) / float64(dr.Dx()) - swMinus1, shMinus1 := sw-1, sh-1 - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (float64(dy)+0.5)*yscale - 0.5 - // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if - // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for - // sx, below. - sy0 := int32(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy1 := sy0 + 1 - if sy < 0 { - sy0, sy1 = 0, 0 - yFrac0, yFrac1 = 0, 1 - } else if sy1 > shMinus1 { - sy0, sy1 = shMinus1, shMinus1 - yFrac0, yFrac1 = 1, 0 - } - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (float64(dx)+0.5)*xscale - 0.5 - sx0 := int32(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx1 := sx0 + 1 - if sx < 0 { - sx0, sx1 = 0, 0 - xFrac0, xFrac1 = 0, 1 - } else if sx1 > swMinus1 { - sx0, sx1 = swMinus1, swMinus1 - xFrac0, xFrac1 = 1, 0 - } - - s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 - s00au := uint32(src.Pix[s00i+3]) * 0x101 - s00ru := uint32(src.Pix[s00i+0]) * s00au / 0xff - s00gu := uint32(src.Pix[s00i+1]) * s00au / 0xff - s00bu := uint32(src.Pix[s00i+2]) * s00au / 0xff - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 - s10au := uint32(src.Pix[s10i+3]) * 0x101 - s10ru := uint32(src.Pix[s10i+0]) * s10au / 0xff - s10gu := uint32(src.Pix[s10i+1]) * s10au / 0xff - s10bu := uint32(src.Pix[s10i+2]) * s10au / 0xff - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 - s01au := uint32(src.Pix[s01i+3]) * 0x101 - s01ru := uint32(src.Pix[s01i+0]) * s01au / 0xff - s01gu := uint32(src.Pix[s01i+1]) * s01au / 0xff - s01bu := uint32(src.Pix[s01i+2]) * s01au / 0xff - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 - s11au := uint32(src.Pix[s11i+3]) * 0x101 - s11ru := uint32(src.Pix[s11i+0]) * s11au / 0xff - s11gu := uint32(src.Pix[s11i+1]) * s11au / 0xff - s11bu := uint32(src.Pix[s11i+2]) * s11au / 0xff - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = uint8(pa >> 8) - } - } -} - -func (ablInterpolator) scale_RGBA_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle, opts *Options) { - sw := int32(sr.Dx()) - sh := int32(sr.Dy()) - yscale := float64(sh) / float64(dr.Dy()) - xscale := float64(sw) / float64(dr.Dx()) - swMinus1, shMinus1 := sw-1, sh-1 - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (float64(dy)+0.5)*yscale - 0.5 - // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if - // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for - // sx, below. - sy0 := int32(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy1 := sy0 + 1 - if sy < 0 { - sy0, sy1 = 0, 0 - yFrac0, yFrac1 = 0, 1 - } else if sy1 > shMinus1 { - sy0, sy1 = shMinus1, shMinus1 - yFrac0, yFrac1 = 1, 0 - } - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (float64(dx)+0.5)*xscale - 0.5 - sx0 := int32(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx1 := sx0 + 1 - if sx < 0 { - sx0, sx1 = 0, 0 - xFrac0, xFrac1 = 0, 1 - } else if sx1 > swMinus1 { - sx0, sx1 = swMinus1, swMinus1 - xFrac0, xFrac1 = 1, 0 - } - - s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 - s00ru := uint32(src.Pix[s00i+0]) * 0x101 - s00gu := uint32(src.Pix[s00i+1]) * 0x101 - s00bu := uint32(src.Pix[s00i+2]) * 0x101 - s00au := uint32(src.Pix[s00i+3]) * 0x101 - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 - s10ru := uint32(src.Pix[s10i+0]) * 0x101 - s10gu := uint32(src.Pix[s10i+1]) * 0x101 - s10bu := uint32(src.Pix[s10i+2]) * 0x101 - s10au := uint32(src.Pix[s10i+3]) * 0x101 - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 - s01ru := uint32(src.Pix[s01i+0]) * 0x101 - s01gu := uint32(src.Pix[s01i+1]) * 0x101 - s01bu := uint32(src.Pix[s01i+2]) * 0x101 - s01au := uint32(src.Pix[s01i+3]) * 0x101 - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 - s11ru := uint32(src.Pix[s11i+0]) * 0x101 - s11gu := uint32(src.Pix[s11i+1]) * 0x101 - s11bu := uint32(src.Pix[s11i+2]) * 0x101 - s11au := uint32(src.Pix[s11i+3]) * 0x101 - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - pa1 := (0xffff - pa) * 0x101 - 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) - } - } -} - -func (ablInterpolator) scale_RGBA_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle, opts *Options) { - sw := int32(sr.Dx()) - sh := int32(sr.Dy()) - yscale := float64(sh) / float64(dr.Dy()) - xscale := float64(sw) / float64(dr.Dx()) - swMinus1, shMinus1 := sw-1, sh-1 - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (float64(dy)+0.5)*yscale - 0.5 - // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if - // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for - // sx, below. - sy0 := int32(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy1 := sy0 + 1 - if sy < 0 { - sy0, sy1 = 0, 0 - yFrac0, yFrac1 = 0, 1 - } else if sy1 > shMinus1 { - sy0, sy1 = shMinus1, shMinus1 - yFrac0, yFrac1 = 1, 0 - } - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (float64(dx)+0.5)*xscale - 0.5 - sx0 := int32(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx1 := sx0 + 1 - if sx < 0 { - sx0, sx1 = 0, 0 - xFrac0, xFrac1 = 0, 1 - } else if sx1 > swMinus1 { - sx0, sx1 = swMinus1, swMinus1 - xFrac0, xFrac1 = 1, 0 - } - - s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 - s00ru := uint32(src.Pix[s00i+0]) * 0x101 - s00gu := uint32(src.Pix[s00i+1]) * 0x101 - s00bu := uint32(src.Pix[s00i+2]) * 0x101 - s00au := uint32(src.Pix[s00i+3]) * 0x101 - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 - s10ru := uint32(src.Pix[s10i+0]) * 0x101 - s10gu := uint32(src.Pix[s10i+1]) * 0x101 - s10bu := uint32(src.Pix[s10i+2]) * 0x101 - s10au := uint32(src.Pix[s10i+3]) * 0x101 - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4 - s01ru := uint32(src.Pix[s01i+0]) * 0x101 - s01gu := uint32(src.Pix[s01i+1]) * 0x101 - s01bu := uint32(src.Pix[s01i+2]) * 0x101 - s01au := uint32(src.Pix[s01i+3]) * 0x101 - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4 - s11ru := uint32(src.Pix[s11i+0]) * 0x101 - s11gu := uint32(src.Pix[s11i+1]) * 0x101 - s11bu := uint32(src.Pix[s11i+2]) * 0x101 - s11au := uint32(src.Pix[s11i+3]) * 0x101 - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = uint8(pa >> 8) - } - } -} - -func (ablInterpolator) scale_RGBA_YCbCr444_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { - sw := int32(sr.Dx()) - sh := int32(sr.Dy()) - yscale := float64(sh) / float64(dr.Dy()) - xscale := float64(sw) / float64(dr.Dx()) - swMinus1, shMinus1 := sw-1, sh-1 - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (float64(dy)+0.5)*yscale - 0.5 - // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if - // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for - // sx, below. - sy0 := int32(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy1 := sy0 + 1 - if sy < 0 { - sy0, sy1 = 0, 0 - yFrac0, yFrac1 = 0, 1 - } else if sy1 > shMinus1 { - sy0, sy1 = shMinus1, shMinus1 - yFrac0, yFrac1 = 1, 0 - } - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (float64(dx)+0.5)*xscale - 0.5 - sx0 := int32(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx1 := sx0 + 1 - if sx < 0 { - sx0, sx1 = 0, 0 - xFrac0, xFrac1 = 0, 1 - } else if sx1 > swMinus1 { - sx0, sx1 = swMinus1, swMinus1 - xFrac0, xFrac1 = 1, 0 - } - - s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) - s00j := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.CStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s00yy1 := int(src.Y[s00i]) * 0x10101 - s00cb1 := int(src.Cb[s00j]) - 128 - s00cr1 := int(src.Cr[s00j]) - 128 - s00ru := (s00yy1 + 91881*s00cr1) >> 8 - s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 - s00bu := (s00yy1 + 116130*s00cb1) >> 8 - if s00ru < 0 { - s00ru = 0 - } else if s00ru > 0xffff { - s00ru = 0xffff - } - if s00gu < 0 { - s00gu = 0 - } else if s00gu > 0xffff { - s00gu = 0xffff - } - if s00bu < 0 { - s00bu = 0 - } else if s00bu > 0xffff { - s00bu = 0xffff - } - - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) - s10j := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.CStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s10yy1 := int(src.Y[s10i]) * 0x10101 - s10cb1 := int(src.Cb[s10j]) - 128 - s10cr1 := int(src.Cr[s10j]) - 128 - s10ru := (s10yy1 + 91881*s10cr1) >> 8 - s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 - s10bu := (s10yy1 + 116130*s10cb1) >> 8 - if s10ru < 0 { - s10ru = 0 - } else if s10ru > 0xffff { - s10ru = 0xffff - } - if s10gu < 0 { - s10gu = 0 - } else if s10gu > 0xffff { - s10gu = 0xffff - } - if s10bu < 0 { - s10bu = 0 - } else if s10bu > 0xffff { - s10bu = 0xffff - } - - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) - s01j := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.CStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s01yy1 := int(src.Y[s01i]) * 0x10101 - s01cb1 := int(src.Cb[s01j]) - 128 - s01cr1 := int(src.Cr[s01j]) - 128 - s01ru := (s01yy1 + 91881*s01cr1) >> 8 - s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 - s01bu := (s01yy1 + 116130*s01cb1) >> 8 - if s01ru < 0 { - s01ru = 0 - } else if s01ru > 0xffff { - s01ru = 0xffff - } - if s01gu < 0 { - s01gu = 0 - } else if s01gu > 0xffff { - s01gu = 0xffff - } - if s01bu < 0 { - s01bu = 0 - } else if s01bu > 0xffff { - s01bu = 0xffff - } - - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) - s11j := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.CStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s11yy1 := int(src.Y[s11i]) * 0x10101 - s11cb1 := int(src.Cb[s11j]) - 128 - s11cr1 := int(src.Cr[s11j]) - 128 - s11ru := (s11yy1 + 91881*s11cr1) >> 8 - s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 - s11bu := (s11yy1 + 116130*s11cb1) >> 8 - if s11ru < 0 { - s11ru = 0 - } else if s11ru > 0xffff { - s11ru = 0xffff - } - if s11gu < 0 { - s11gu = 0 - } else if s11gu > 0xffff { - s11gu = 0xffff - } - if s11bu < 0 { - s11bu = 0 - } else if s11bu > 0xffff { - s11bu = 0xffff - } - - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (ablInterpolator) scale_RGBA_YCbCr422_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { - sw := int32(sr.Dx()) - sh := int32(sr.Dy()) - yscale := float64(sh) / float64(dr.Dy()) - xscale := float64(sw) / float64(dr.Dx()) - swMinus1, shMinus1 := sw-1, sh-1 - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (float64(dy)+0.5)*yscale - 0.5 - // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if - // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for - // sx, below. - sy0 := int32(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy1 := sy0 + 1 - if sy < 0 { - sy0, sy1 = 0, 0 - yFrac0, yFrac1 = 0, 1 - } else if sy1 > shMinus1 { - sy0, sy1 = shMinus1, shMinus1 - yFrac0, yFrac1 = 1, 0 - } - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (float64(dx)+0.5)*xscale - 0.5 - sx0 := int32(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx1 := sx0 + 1 - if sx < 0 { - sx0, sx1 = 0, 0 - xFrac0, xFrac1 = 0, 1 - } else if sx1 > swMinus1 { - sx0, sx1 = swMinus1, swMinus1 - xFrac0, xFrac1 = 1, 0 - } - - s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) - s00j := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.CStride + ((sr.Min.X+int(sx0))/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s00yy1 := int(src.Y[s00i]) * 0x10101 - s00cb1 := int(src.Cb[s00j]) - 128 - s00cr1 := int(src.Cr[s00j]) - 128 - s00ru := (s00yy1 + 91881*s00cr1) >> 8 - s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 - s00bu := (s00yy1 + 116130*s00cb1) >> 8 - if s00ru < 0 { - s00ru = 0 - } else if s00ru > 0xffff { - s00ru = 0xffff - } - if s00gu < 0 { - s00gu = 0 - } else if s00gu > 0xffff { - s00gu = 0xffff - } - if s00bu < 0 { - s00bu = 0 - } else if s00bu > 0xffff { - s00bu = 0xffff - } - - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) - s10j := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.CStride + ((sr.Min.X+int(sx1))/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s10yy1 := int(src.Y[s10i]) * 0x10101 - s10cb1 := int(src.Cb[s10j]) - 128 - s10cr1 := int(src.Cr[s10j]) - 128 - s10ru := (s10yy1 + 91881*s10cr1) >> 8 - s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 - s10bu := (s10yy1 + 116130*s10cb1) >> 8 - if s10ru < 0 { - s10ru = 0 - } else if s10ru > 0xffff { - s10ru = 0xffff - } - if s10gu < 0 { - s10gu = 0 - } else if s10gu > 0xffff { - s10gu = 0xffff - } - if s10bu < 0 { - s10bu = 0 - } else if s10bu > 0xffff { - s10bu = 0xffff - } - - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) - s01j := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.CStride + ((sr.Min.X+int(sx0))/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s01yy1 := int(src.Y[s01i]) * 0x10101 - s01cb1 := int(src.Cb[s01j]) - 128 - s01cr1 := int(src.Cr[s01j]) - 128 - s01ru := (s01yy1 + 91881*s01cr1) >> 8 - s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 - s01bu := (s01yy1 + 116130*s01cb1) >> 8 - if s01ru < 0 { - s01ru = 0 - } else if s01ru > 0xffff { - s01ru = 0xffff - } - if s01gu < 0 { - s01gu = 0 - } else if s01gu > 0xffff { - s01gu = 0xffff - } - if s01bu < 0 { - s01bu = 0 - } else if s01bu > 0xffff { - s01bu = 0xffff - } - - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) - s11j := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.CStride + ((sr.Min.X+int(sx1))/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s11yy1 := int(src.Y[s11i]) * 0x10101 - s11cb1 := int(src.Cb[s11j]) - 128 - s11cr1 := int(src.Cr[s11j]) - 128 - s11ru := (s11yy1 + 91881*s11cr1) >> 8 - s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 - s11bu := (s11yy1 + 116130*s11cb1) >> 8 - if s11ru < 0 { - s11ru = 0 - } else if s11ru > 0xffff { - s11ru = 0xffff - } - if s11gu < 0 { - s11gu = 0 - } else if s11gu > 0xffff { - s11gu = 0xffff - } - if s11bu < 0 { - s11bu = 0 - } else if s11bu > 0xffff { - s11bu = 0xffff - } - - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (ablInterpolator) scale_RGBA_YCbCr420_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { - sw := int32(sr.Dx()) - sh := int32(sr.Dy()) - yscale := float64(sh) / float64(dr.Dy()) - xscale := float64(sw) / float64(dr.Dx()) - swMinus1, shMinus1 := sw-1, sh-1 - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (float64(dy)+0.5)*yscale - 0.5 - // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if - // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for - // sx, below. - sy0 := int32(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy1 := sy0 + 1 - if sy < 0 { - sy0, sy1 = 0, 0 - yFrac0, yFrac1 = 0, 1 - } else if sy1 > shMinus1 { - sy0, sy1 = shMinus1, shMinus1 - yFrac0, yFrac1 = 1, 0 - } - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (float64(dx)+0.5)*xscale - 0.5 - sx0 := int32(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx1 := sx0 + 1 - if sx < 0 { - sx0, sx1 = 0, 0 - xFrac0, xFrac1 = 0, 1 - } else if sx1 > swMinus1 { - sx0, sx1 = swMinus1, swMinus1 - xFrac0, xFrac1 = 1, 0 - } - - s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) - s00j := ((sr.Min.Y+int(sy0))/2-src.Rect.Min.Y/2)*src.CStride + ((sr.Min.X+int(sx0))/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s00yy1 := int(src.Y[s00i]) * 0x10101 - s00cb1 := int(src.Cb[s00j]) - 128 - s00cr1 := int(src.Cr[s00j]) - 128 - s00ru := (s00yy1 + 91881*s00cr1) >> 8 - s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 - s00bu := (s00yy1 + 116130*s00cb1) >> 8 - if s00ru < 0 { - s00ru = 0 - } else if s00ru > 0xffff { - s00ru = 0xffff - } - if s00gu < 0 { - s00gu = 0 - } else if s00gu > 0xffff { - s00gu = 0xffff - } - if s00bu < 0 { - s00bu = 0 - } else if s00bu > 0xffff { - s00bu = 0xffff - } - - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) - s10j := ((sr.Min.Y+int(sy0))/2-src.Rect.Min.Y/2)*src.CStride + ((sr.Min.X+int(sx1))/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s10yy1 := int(src.Y[s10i]) * 0x10101 - s10cb1 := int(src.Cb[s10j]) - 128 - s10cr1 := int(src.Cr[s10j]) - 128 - s10ru := (s10yy1 + 91881*s10cr1) >> 8 - s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 - s10bu := (s10yy1 + 116130*s10cb1) >> 8 - if s10ru < 0 { - s10ru = 0 - } else if s10ru > 0xffff { - s10ru = 0xffff - } - if s10gu < 0 { - s10gu = 0 - } else if s10gu > 0xffff { - s10gu = 0xffff - } - if s10bu < 0 { - s10bu = 0 - } else if s10bu > 0xffff { - s10bu = 0xffff - } - - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) - s01j := ((sr.Min.Y+int(sy1))/2-src.Rect.Min.Y/2)*src.CStride + ((sr.Min.X+int(sx0))/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s01yy1 := int(src.Y[s01i]) * 0x10101 - s01cb1 := int(src.Cb[s01j]) - 128 - s01cr1 := int(src.Cr[s01j]) - 128 - s01ru := (s01yy1 + 91881*s01cr1) >> 8 - s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 - s01bu := (s01yy1 + 116130*s01cb1) >> 8 - if s01ru < 0 { - s01ru = 0 - } else if s01ru > 0xffff { - s01ru = 0xffff - } - if s01gu < 0 { - s01gu = 0 - } else if s01gu > 0xffff { - s01gu = 0xffff - } - if s01bu < 0 { - s01bu = 0 - } else if s01bu > 0xffff { - s01bu = 0xffff - } - - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) - s11j := ((sr.Min.Y+int(sy1))/2-src.Rect.Min.Y/2)*src.CStride + ((sr.Min.X+int(sx1))/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s11yy1 := int(src.Y[s11i]) * 0x10101 - s11cb1 := int(src.Cb[s11j]) - 128 - s11cr1 := int(src.Cr[s11j]) - 128 - s11ru := (s11yy1 + 91881*s11cr1) >> 8 - s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 - s11bu := (s11yy1 + 116130*s11cb1) >> 8 - if s11ru < 0 { - s11ru = 0 - } else if s11ru > 0xffff { - s11ru = 0xffff - } - if s11gu < 0 { - s11gu = 0 - } else if s11gu > 0xffff { - s11gu = 0xffff - } - if s11bu < 0 { - s11bu = 0 - } else if s11bu > 0xffff { - s11bu = 0xffff - } - - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (ablInterpolator) scale_RGBA_YCbCr440_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) { - sw := int32(sr.Dx()) - sh := int32(sr.Dy()) - yscale := float64(sh) / float64(dr.Dy()) - xscale := float64(sw) / float64(dr.Dx()) - swMinus1, shMinus1 := sw-1, sh-1 - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (float64(dy)+0.5)*yscale - 0.5 - // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if - // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for - // sx, below. - sy0 := int32(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy1 := sy0 + 1 - if sy < 0 { - sy0, sy1 = 0, 0 - yFrac0, yFrac1 = 0, 1 - } else if sy1 > shMinus1 { - sy0, sy1 = shMinus1, shMinus1 - yFrac0, yFrac1 = 1, 0 - } - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (float64(dx)+0.5)*xscale - 0.5 - sx0 := int32(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx1 := sx0 + 1 - if sx < 0 { - sx0, sx1 = 0, 0 - xFrac0, xFrac1 = 0, 1 - } else if sx1 > swMinus1 { - sx0, sx1 = swMinus1, swMinus1 - xFrac0, xFrac1 = 1, 0 - } - - s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) - s00j := ((sr.Min.Y+int(sy0))/2-src.Rect.Min.Y/2)*src.CStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s00yy1 := int(src.Y[s00i]) * 0x10101 - s00cb1 := int(src.Cb[s00j]) - 128 - s00cr1 := int(src.Cr[s00j]) - 128 - s00ru := (s00yy1 + 91881*s00cr1) >> 8 - s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 - s00bu := (s00yy1 + 116130*s00cb1) >> 8 - if s00ru < 0 { - s00ru = 0 - } else if s00ru > 0xffff { - s00ru = 0xffff - } - if s00gu < 0 { - s00gu = 0 - } else if s00gu > 0xffff { - s00gu = 0xffff - } - if s00bu < 0 { - s00bu = 0 - } else if s00bu > 0xffff { - s00bu = 0xffff - } - - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) - s10j := ((sr.Min.Y+int(sy0))/2-src.Rect.Min.Y/2)*src.CStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s10yy1 := int(src.Y[s10i]) * 0x10101 - s10cb1 := int(src.Cb[s10j]) - 128 - s10cr1 := int(src.Cr[s10j]) - 128 - s10ru := (s10yy1 + 91881*s10cr1) >> 8 - s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 - s10bu := (s10yy1 + 116130*s10cb1) >> 8 - if s10ru < 0 { - s10ru = 0 - } else if s10ru > 0xffff { - s10ru = 0xffff - } - if s10gu < 0 { - s10gu = 0 - } else if s10gu > 0xffff { - s10gu = 0xffff - } - if s10bu < 0 { - s10bu = 0 - } else if s10bu > 0xffff { - s10bu = 0xffff - } - - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) - s01j := ((sr.Min.Y+int(sy1))/2-src.Rect.Min.Y/2)*src.CStride + (sr.Min.X + int(sx0) - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s01yy1 := int(src.Y[s01i]) * 0x10101 - s01cb1 := int(src.Cb[s01j]) - 128 - s01cr1 := int(src.Cr[s01j]) - 128 - s01ru := (s01yy1 + 91881*s01cr1) >> 8 - s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 - s01bu := (s01yy1 + 116130*s01cb1) >> 8 - if s01ru < 0 { - s01ru = 0 - } else if s01ru > 0xffff { - s01ru = 0xffff - } - if s01gu < 0 { - s01gu = 0 - } else if s01gu > 0xffff { - s01gu = 0xffff - } - if s01bu < 0 { - s01bu = 0 - } else if s01bu > 0xffff { - s01bu = 0xffff - } - - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) - s11j := ((sr.Min.Y+int(sy1))/2-src.Rect.Min.Y/2)*src.CStride + (sr.Min.X + int(sx1) - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s11yy1 := int(src.Y[s11i]) * 0x10101 - s11cb1 := int(src.Cb[s11j]) - 128 - s11cr1 := int(src.Cr[s11j]) - 128 - s11ru := (s11yy1 + 91881*s11cr1) >> 8 - s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 - s11bu := (s11yy1 + 116130*s11cb1) >> 8 - if s11ru < 0 { - s11ru = 0 - } else if s11ru > 0xffff { - s11ru = 0xffff - } - if s11gu < 0 { - s11gu = 0 - } else if s11gu > 0xffff { - s11gu = 0xffff - } - if s11bu < 0 { - s11bu = 0 - } else if s11bu > 0xffff { - s11bu = 0xffff - } - - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (ablInterpolator) scale_RGBA_Image_Over(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { - sw := int32(sr.Dx()) - sh := int32(sr.Dy()) - yscale := float64(sh) / float64(dr.Dy()) - xscale := float64(sw) / float64(dr.Dx()) - swMinus1, shMinus1 := sw-1, sh-1 - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (float64(dy)+0.5)*yscale - 0.5 - // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if - // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for - // sx, below. - sy0 := int32(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy1 := sy0 + 1 - if sy < 0 { - sy0, sy1 = 0, 0 - yFrac0, yFrac1 = 0, 1 - } else if sy1 > shMinus1 { - sy0, sy1 = shMinus1, shMinus1 - yFrac0, yFrac1 = 1, 0 - } - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (float64(dx)+0.5)*xscale - 0.5 - sx0 := int32(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx1 := sx0 + 1 - if sx < 0 { - sx0, sx1 = 0, 0 - xFrac0, xFrac1 = 0, 1 - } else if sx1 > swMinus1 { - sx0, sx1 = swMinus1, swMinus1 - xFrac0, xFrac1 = 1, 0 - } - - s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA() - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA() - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA() - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA() - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - pa1 := (0xffff - pa) * 0x101 - 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) - } - } -} - -func (ablInterpolator) scale_RGBA_Image_Src(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { - sw := int32(sr.Dx()) - sh := int32(sr.Dy()) - yscale := float64(sh) / float64(dr.Dy()) - xscale := float64(sw) / float64(dr.Dx()) - swMinus1, shMinus1 := sw-1, sh-1 - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (float64(dy)+0.5)*yscale - 0.5 - // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if - // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for - // sx, below. - sy0 := int32(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy1 := sy0 + 1 - if sy < 0 { - sy0, sy1 = 0, 0 - yFrac0, yFrac1 = 0, 1 - } else if sy1 > shMinus1 { - sy0, sy1 = shMinus1, shMinus1 - yFrac0, yFrac1 = 1, 0 - } - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 { - sx := (float64(dx)+0.5)*xscale - 0.5 - sx0 := int32(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx1 := sx0 + 1 - if sx < 0 { - sx0, sx1 = 0, 0 - xFrac0, xFrac1 = 0, 1 - } else if sx1 > swMinus1 { - sx0, sx1 = swMinus1, swMinus1 - xFrac0, xFrac1 = 1, 0 - } - - s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA() - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA() - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA() - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA() - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = uint8(pa >> 8) - } - } -} - -func (ablInterpolator) scale_Image_Image_Over(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { - sw := int32(sr.Dx()) - sh := int32(sr.Dy()) - yscale := float64(sh) / float64(dr.Dy()) - xscale := float64(sw) / float64(dr.Dx()) - swMinus1, shMinus1 := sw-1, sh-1 - srcMask, smp := opts.SrcMask, opts.SrcMaskP - dstMask, dmp := opts.DstMask, opts.DstMaskP - dstColorRGBA64 := &color.RGBA64{} - dstColor := color.Color(dstColorRGBA64) - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (float64(dy)+0.5)*yscale - 0.5 - // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if - // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for - // sx, below. - sy0 := int32(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy1 := sy0 + 1 - if sy < 0 { - sy0, sy1 = 0, 0 - yFrac0, yFrac1 = 0, 1 - } else if sy1 > shMinus1 { - sy0, sy1 = shMinus1, shMinus1 - yFrac0, yFrac1 = 1, 0 - } - - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - sx := (float64(dx)+0.5)*xscale - 0.5 - sx0 := int32(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx1 := sx0 + 1 - if sx < 0 { - sx0, sx1 = 0, 0 - xFrac0, xFrac1 = 0, 1 - } else if sx1 > swMinus1 { - sx0, sx1 = swMinus1, swMinus1 - xFrac0, xFrac1 = 1, 0 - } - - s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx0), smp.Y+sr.Min.Y+int(sy0)).RGBA() - s00ru = s00ru * ma / 0xffff - s00gu = s00gu * ma / 0xffff - s00bu = s00bu * ma / 0xffff - s00au = s00au * ma / 0xffff - } - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx1), smp.Y+sr.Min.Y+int(sy0)).RGBA() - s10ru = s10ru * ma / 0xffff - s10gu = s10gu * ma / 0xffff - s10bu = s10bu * ma / 0xffff - s10au = s10au * ma / 0xffff - } - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx0), smp.Y+sr.Min.Y+int(sy1)).RGBA() - s01ru = s01ru * ma / 0xffff - s01gu = s01gu * ma / 0xffff - s01bu = s01bu * ma / 0xffff - s01au = s01au * ma / 0xffff - } - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx1), smp.Y+sr.Min.Y+int(sy1)).RGBA() - s11ru = s11ru * ma / 0xffff - s11gu = s11gu * ma / 0xffff - s11bu = s11bu * ma / 0xffff - s11au = s11au * ma / 0xffff - } - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() - if dstMask != nil { - _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() - pr = pr * ma / 0xffff - pg = pg * ma / 0xffff - pb = pb * ma / 0xffff - pa = pa * ma / 0xffff - } - pa1 := 0xffff - pa - 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) - } - } -} - -func (ablInterpolator) scale_Image_Image_Src(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) { - sw := int32(sr.Dx()) - sh := int32(sr.Dy()) - yscale := float64(sh) / float64(dr.Dy()) - xscale := float64(sw) / float64(dr.Dx()) - swMinus1, shMinus1 := sw-1, sh-1 - srcMask, smp := opts.SrcMask, opts.SrcMaskP - dstMask, dmp := opts.DstMask, opts.DstMaskP - dstColorRGBA64 := &color.RGBA64{} - dstColor := color.Color(dstColorRGBA64) - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - sy := (float64(dy)+0.5)*yscale - 0.5 - // If sy < 0, we will clamp sy0 to 0 anyway, so it doesn't matter if - // we say int32(sy) instead of int32(math.Floor(sy)). Similarly for - // sx, below. - sy0 := int32(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy1 := sy0 + 1 - if sy < 0 { - sy0, sy1 = 0, 0 - yFrac0, yFrac1 = 0, 1 - } else if sy1 > shMinus1 { - sy0, sy1 = shMinus1, shMinus1 - yFrac0, yFrac1 = 1, 0 - } - - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - sx := (float64(dx)+0.5)*xscale - 0.5 - sx0 := int32(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx1 := sx0 + 1 - if sx < 0 { - sx0, sx1 = 0, 0 - xFrac0, xFrac1 = 0, 1 - } else if sx1 > swMinus1 { - sx0, sx1 = swMinus1, swMinus1 - xFrac0, xFrac1 = 1, 0 - } - - s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx0), smp.Y+sr.Min.Y+int(sy0)).RGBA() - s00ru = s00ru * ma / 0xffff - s00gu = s00gu * ma / 0xffff - s00bu = s00bu * ma / 0xffff - s00au = s00au * ma / 0xffff - } - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx1), smp.Y+sr.Min.Y+int(sy0)).RGBA() - s10ru = s10ru * ma / 0xffff - s10gu = s10gu * ma / 0xffff - s10bu = s10bu * ma / 0xffff - s10au = s10au * ma / 0xffff - } - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx0), smp.Y+sr.Min.Y+int(sy1)).RGBA() - s01ru = s01ru * ma / 0xffff - s01gu = s01gu * ma / 0xffff - s01bu = s01bu * ma / 0xffff - s01au = s01au * ma / 0xffff - } - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(sx1), smp.Y+sr.Min.Y+int(sy1)).RGBA() - s11ru = s11ru * ma / 0xffff - s11gu = s11gu * ma / 0xffff - s11bu = s11bu * ma / 0xffff - s11au = s11au * ma / 0xffff - } - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - if dstMask != nil { - qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() - _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() - pr = pr * ma / 0xffff - pg = pg * ma / 0xffff - pb = pb * ma / 0xffff - pa = pa * ma / 0xffff - pa1 := 0xffff - ma - 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) - } else { - dstColorRGBA64.R = uint16(pr) - dstColorRGBA64.G = uint16(pg) - dstColorRGBA64.B = uint16(pb) - dstColorRGBA64.A = uint16(pa) - dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) - } - } - } -} - -func (ablInterpolator) transform_RGBA_Gray_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Gray, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - sx -= 0.5 - sx0 := int(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx0 += bias.X - sx1 := sx0 + 1 - if sx0 < sr.Min.X { - sx0, sx1 = sr.Min.X, sr.Min.X - xFrac0, xFrac1 = 0, 1 - } else if sx1 >= sr.Max.X { - sx0, sx1 = sr.Max.X-1, sr.Max.X-1 - xFrac0, xFrac1 = 1, 0 - } - - sy -= 0.5 - sy0 := int(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy0 += bias.Y - sy1 := sy0 + 1 - if sy0 < sr.Min.Y { - sy0, sy1 = sr.Min.Y, sr.Min.Y - yFrac0, yFrac1 = 0, 1 - } else if sy1 >= sr.Max.Y { - sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 - yFrac0, yFrac1 = 1, 0 - } - - s00i := (sy0-src.Rect.Min.Y)*src.Stride + (sx0 - src.Rect.Min.X) - s00ru := uint32(src.Pix[s00i]) * 0x101 - s00r := float64(s00ru) - s10i := (sy0-src.Rect.Min.Y)*src.Stride + (sx1 - src.Rect.Min.X) - s10ru := uint32(src.Pix[s10i]) * 0x101 - s10r := float64(s10ru) - s10r = xFrac1*s00r + xFrac0*s10r - s01i := (sy1-src.Rect.Min.Y)*src.Stride + (sx0 - src.Rect.Min.X) - s01ru := uint32(src.Pix[s01i]) * 0x101 - s01r := float64(s01ru) - s11i := (sy1-src.Rect.Min.Y)*src.Stride + (sx1 - src.Rect.Min.X) - s11ru := uint32(src.Pix[s11i]) * 0x101 - s11r := float64(s11ru) - s11r = xFrac1*s01r + xFrac0*s11r - s11r = yFrac1*s10r + yFrac0*s11r - pr := uint32(s11r) - out := uint8(pr >> 8) - dst.Pix[d+0] = out - dst.Pix[d+1] = out - dst.Pix[d+2] = out - dst.Pix[d+3] = 0xff - } - } -} - -func (ablInterpolator) transform_RGBA_NRGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - sx -= 0.5 - sx0 := int(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx0 += bias.X - sx1 := sx0 + 1 - if sx0 < sr.Min.X { - sx0, sx1 = sr.Min.X, sr.Min.X - xFrac0, xFrac1 = 0, 1 - } else if sx1 >= sr.Max.X { - sx0, sx1 = sr.Max.X-1, sr.Max.X-1 - xFrac0, xFrac1 = 1, 0 - } - - sy -= 0.5 - sy0 := int(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy0 += bias.Y - sy1 := sy0 + 1 - if sy0 < sr.Min.Y { - sy0, sy1 = sr.Min.Y, sr.Min.Y - yFrac0, yFrac1 = 0, 1 - } else if sy1 >= sr.Max.Y { - sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 - yFrac0, yFrac1 = 1, 0 - } - - s00i := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 - s00au := uint32(src.Pix[s00i+3]) * 0x101 - s00ru := uint32(src.Pix[s00i+0]) * s00au / 0xff - s00gu := uint32(src.Pix[s00i+1]) * s00au / 0xff - s00bu := uint32(src.Pix[s00i+2]) * s00au / 0xff - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10i := (sy0-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 - s10au := uint32(src.Pix[s10i+3]) * 0x101 - s10ru := uint32(src.Pix[s10i+0]) * s10au / 0xff - s10gu := uint32(src.Pix[s10i+1]) * s10au / 0xff - s10bu := uint32(src.Pix[s10i+2]) * s10au / 0xff - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01i := (sy1-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 - s01au := uint32(src.Pix[s01i+3]) * 0x101 - s01ru := uint32(src.Pix[s01i+0]) * s01au / 0xff - s01gu := uint32(src.Pix[s01i+1]) * s01au / 0xff - s01bu := uint32(src.Pix[s01i+2]) * s01au / 0xff - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11i := (sy1-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 - s11au := uint32(src.Pix[s11i+3]) * 0x101 - s11ru := uint32(src.Pix[s11i+0]) * s11au / 0xff - s11gu := uint32(src.Pix[s11i+1]) * s11au / 0xff - s11bu := uint32(src.Pix[s11i+2]) * s11au / 0xff - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - pa1 := (0xffff - pa) * 0x101 - 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) - } - } -} - -func (ablInterpolator) transform_RGBA_NRGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - sx -= 0.5 - sx0 := int(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx0 += bias.X - sx1 := sx0 + 1 - if sx0 < sr.Min.X { - sx0, sx1 = sr.Min.X, sr.Min.X - xFrac0, xFrac1 = 0, 1 - } else if sx1 >= sr.Max.X { - sx0, sx1 = sr.Max.X-1, sr.Max.X-1 - xFrac0, xFrac1 = 1, 0 - } - - sy -= 0.5 - sy0 := int(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy0 += bias.Y - sy1 := sy0 + 1 - if sy0 < sr.Min.Y { - sy0, sy1 = sr.Min.Y, sr.Min.Y - yFrac0, yFrac1 = 0, 1 - } else if sy1 >= sr.Max.Y { - sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 - yFrac0, yFrac1 = 1, 0 - } - - s00i := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 - s00au := uint32(src.Pix[s00i+3]) * 0x101 - s00ru := uint32(src.Pix[s00i+0]) * s00au / 0xff - s00gu := uint32(src.Pix[s00i+1]) * s00au / 0xff - s00bu := uint32(src.Pix[s00i+2]) * s00au / 0xff - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10i := (sy0-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 - s10au := uint32(src.Pix[s10i+3]) * 0x101 - s10ru := uint32(src.Pix[s10i+0]) * s10au / 0xff - s10gu := uint32(src.Pix[s10i+1]) * s10au / 0xff - s10bu := uint32(src.Pix[s10i+2]) * s10au / 0xff - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01i := (sy1-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 - s01au := uint32(src.Pix[s01i+3]) * 0x101 - s01ru := uint32(src.Pix[s01i+0]) * s01au / 0xff - s01gu := uint32(src.Pix[s01i+1]) * s01au / 0xff - s01bu := uint32(src.Pix[s01i+2]) * s01au / 0xff - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11i := (sy1-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 - s11au := uint32(src.Pix[s11i+3]) * 0x101 - s11ru := uint32(src.Pix[s11i+0]) * s11au / 0xff - s11gu := uint32(src.Pix[s11i+1]) * s11au / 0xff - s11bu := uint32(src.Pix[s11i+2]) * s11au / 0xff - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = uint8(pa >> 8) - } - } -} - -func (ablInterpolator) transform_RGBA_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - sx -= 0.5 - sx0 := int(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx0 += bias.X - sx1 := sx0 + 1 - if sx0 < sr.Min.X { - sx0, sx1 = sr.Min.X, sr.Min.X - xFrac0, xFrac1 = 0, 1 - } else if sx1 >= sr.Max.X { - sx0, sx1 = sr.Max.X-1, sr.Max.X-1 - xFrac0, xFrac1 = 1, 0 - } - - sy -= 0.5 - sy0 := int(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy0 += bias.Y - sy1 := sy0 + 1 - if sy0 < sr.Min.Y { - sy0, sy1 = sr.Min.Y, sr.Min.Y - yFrac0, yFrac1 = 0, 1 - } else if sy1 >= sr.Max.Y { - sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 - yFrac0, yFrac1 = 1, 0 - } - - s00i := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 - s00ru := uint32(src.Pix[s00i+0]) * 0x101 - s00gu := uint32(src.Pix[s00i+1]) * 0x101 - s00bu := uint32(src.Pix[s00i+2]) * 0x101 - s00au := uint32(src.Pix[s00i+3]) * 0x101 - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10i := (sy0-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 - s10ru := uint32(src.Pix[s10i+0]) * 0x101 - s10gu := uint32(src.Pix[s10i+1]) * 0x101 - s10bu := uint32(src.Pix[s10i+2]) * 0x101 - s10au := uint32(src.Pix[s10i+3]) * 0x101 - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01i := (sy1-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 - s01ru := uint32(src.Pix[s01i+0]) * 0x101 - s01gu := uint32(src.Pix[s01i+1]) * 0x101 - s01bu := uint32(src.Pix[s01i+2]) * 0x101 - s01au := uint32(src.Pix[s01i+3]) * 0x101 - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11i := (sy1-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 - s11ru := uint32(src.Pix[s11i+0]) * 0x101 - s11gu := uint32(src.Pix[s11i+1]) * 0x101 - s11bu := uint32(src.Pix[s11i+2]) * 0x101 - s11au := uint32(src.Pix[s11i+3]) * 0x101 - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - pa1 := (0xffff - pa) * 0x101 - 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) - } - } -} - -func (ablInterpolator) transform_RGBA_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - sx -= 0.5 - sx0 := int(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx0 += bias.X - sx1 := sx0 + 1 - if sx0 < sr.Min.X { - sx0, sx1 = sr.Min.X, sr.Min.X - xFrac0, xFrac1 = 0, 1 - } else if sx1 >= sr.Max.X { - sx0, sx1 = sr.Max.X-1, sr.Max.X-1 - xFrac0, xFrac1 = 1, 0 - } - - sy -= 0.5 - sy0 := int(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy0 += bias.Y - sy1 := sy0 + 1 - if sy0 < sr.Min.Y { - sy0, sy1 = sr.Min.Y, sr.Min.Y - yFrac0, yFrac1 = 0, 1 - } else if sy1 >= sr.Max.Y { - sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 - yFrac0, yFrac1 = 1, 0 - } - - s00i := (sy0-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 - s00ru := uint32(src.Pix[s00i+0]) * 0x101 - s00gu := uint32(src.Pix[s00i+1]) * 0x101 - s00bu := uint32(src.Pix[s00i+2]) * 0x101 - s00au := uint32(src.Pix[s00i+3]) * 0x101 - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10i := (sy0-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 - s10ru := uint32(src.Pix[s10i+0]) * 0x101 - s10gu := uint32(src.Pix[s10i+1]) * 0x101 - s10bu := uint32(src.Pix[s10i+2]) * 0x101 - s10au := uint32(src.Pix[s10i+3]) * 0x101 - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01i := (sy1-src.Rect.Min.Y)*src.Stride + (sx0-src.Rect.Min.X)*4 - s01ru := uint32(src.Pix[s01i+0]) * 0x101 - s01gu := uint32(src.Pix[s01i+1]) * 0x101 - s01bu := uint32(src.Pix[s01i+2]) * 0x101 - s01au := uint32(src.Pix[s01i+3]) * 0x101 - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11i := (sy1-src.Rect.Min.Y)*src.Stride + (sx1-src.Rect.Min.X)*4 - s11ru := uint32(src.Pix[s11i+0]) * 0x101 - s11gu := uint32(src.Pix[s11i+1]) * 0x101 - s11bu := uint32(src.Pix[s11i+2]) * 0x101 - s11au := uint32(src.Pix[s11i+3]) * 0x101 - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = uint8(pa >> 8) - } - } -} - -func (ablInterpolator) transform_RGBA_YCbCr444_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - sx -= 0.5 - sx0 := int(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx0 += bias.X - sx1 := sx0 + 1 - if sx0 < sr.Min.X { - sx0, sx1 = sr.Min.X, sr.Min.X - xFrac0, xFrac1 = 0, 1 - } else if sx1 >= sr.Max.X { - sx0, sx1 = sr.Max.X-1, sr.Max.X-1 - xFrac0, xFrac1 = 1, 0 - } - - sy -= 0.5 - sy0 := int(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy0 += bias.Y - sy1 := sy0 + 1 - if sy0 < sr.Min.Y { - sy0, sy1 = sr.Min.Y, sr.Min.Y - yFrac0, yFrac1 = 0, 1 - } else if sy1 >= sr.Max.Y { - sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 - yFrac0, yFrac1 = 1, 0 - } - - s00i := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) - s00j := (sy0-src.Rect.Min.Y)*src.CStride + (sx0 - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s00yy1 := int(src.Y[s00i]) * 0x10101 - s00cb1 := int(src.Cb[s00j]) - 128 - s00cr1 := int(src.Cr[s00j]) - 128 - s00ru := (s00yy1 + 91881*s00cr1) >> 8 - s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 - s00bu := (s00yy1 + 116130*s00cb1) >> 8 - if s00ru < 0 { - s00ru = 0 - } else if s00ru > 0xffff { - s00ru = 0xffff - } - if s00gu < 0 { - s00gu = 0 - } else if s00gu > 0xffff { - s00gu = 0xffff - } - if s00bu < 0 { - s00bu = 0 - } else if s00bu > 0xffff { - s00bu = 0xffff - } - - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s10i := (sy0-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) - s10j := (sy0-src.Rect.Min.Y)*src.CStride + (sx1 - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s10yy1 := int(src.Y[s10i]) * 0x10101 - s10cb1 := int(src.Cb[s10j]) - 128 - s10cr1 := int(src.Cr[s10j]) - 128 - s10ru := (s10yy1 + 91881*s10cr1) >> 8 - s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 - s10bu := (s10yy1 + 116130*s10cb1) >> 8 - if s10ru < 0 { - s10ru = 0 - } else if s10ru > 0xffff { - s10ru = 0xffff - } - if s10gu < 0 { - s10gu = 0 - } else if s10gu > 0xffff { - s10gu = 0xffff - } - if s10bu < 0 { - s10bu = 0 - } else if s10bu > 0xffff { - s10bu = 0xffff - } - - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s01i := (sy1-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) - s01j := (sy1-src.Rect.Min.Y)*src.CStride + (sx0 - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s01yy1 := int(src.Y[s01i]) * 0x10101 - s01cb1 := int(src.Cb[s01j]) - 128 - s01cr1 := int(src.Cr[s01j]) - 128 - s01ru := (s01yy1 + 91881*s01cr1) >> 8 - s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 - s01bu := (s01yy1 + 116130*s01cb1) >> 8 - if s01ru < 0 { - s01ru = 0 - } else if s01ru > 0xffff { - s01ru = 0xffff - } - if s01gu < 0 { - s01gu = 0 - } else if s01gu > 0xffff { - s01gu = 0xffff - } - if s01bu < 0 { - s01bu = 0 - } else if s01bu > 0xffff { - s01bu = 0xffff - } - - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s11i := (sy1-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) - s11j := (sy1-src.Rect.Min.Y)*src.CStride + (sx1 - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s11yy1 := int(src.Y[s11i]) * 0x10101 - s11cb1 := int(src.Cb[s11j]) - 128 - s11cr1 := int(src.Cr[s11j]) - 128 - s11ru := (s11yy1 + 91881*s11cr1) >> 8 - s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 - s11bu := (s11yy1 + 116130*s11cb1) >> 8 - if s11ru < 0 { - s11ru = 0 - } else if s11ru > 0xffff { - s11ru = 0xffff - } - if s11gu < 0 { - s11gu = 0 - } else if s11gu > 0xffff { - s11gu = 0xffff - } - if s11bu < 0 { - s11bu = 0 - } else if s11bu > 0xffff { - s11bu = 0xffff - } - - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (ablInterpolator) transform_RGBA_YCbCr422_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - sx -= 0.5 - sx0 := int(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx0 += bias.X - sx1 := sx0 + 1 - if sx0 < sr.Min.X { - sx0, sx1 = sr.Min.X, sr.Min.X - xFrac0, xFrac1 = 0, 1 - } else if sx1 >= sr.Max.X { - sx0, sx1 = sr.Max.X-1, sr.Max.X-1 - xFrac0, xFrac1 = 1, 0 - } - - sy -= 0.5 - sy0 := int(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy0 += bias.Y - sy1 := sy0 + 1 - if sy0 < sr.Min.Y { - sy0, sy1 = sr.Min.Y, sr.Min.Y - yFrac0, yFrac1 = 0, 1 - } else if sy1 >= sr.Max.Y { - sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 - yFrac0, yFrac1 = 1, 0 - } - - s00i := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) - s00j := (sy0-src.Rect.Min.Y)*src.CStride + ((sx0)/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s00yy1 := int(src.Y[s00i]) * 0x10101 - s00cb1 := int(src.Cb[s00j]) - 128 - s00cr1 := int(src.Cr[s00j]) - 128 - s00ru := (s00yy1 + 91881*s00cr1) >> 8 - s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 - s00bu := (s00yy1 + 116130*s00cb1) >> 8 - if s00ru < 0 { - s00ru = 0 - } else if s00ru > 0xffff { - s00ru = 0xffff - } - if s00gu < 0 { - s00gu = 0 - } else if s00gu > 0xffff { - s00gu = 0xffff - } - if s00bu < 0 { - s00bu = 0 - } else if s00bu > 0xffff { - s00bu = 0xffff - } - - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s10i := (sy0-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) - s10j := (sy0-src.Rect.Min.Y)*src.CStride + ((sx1)/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s10yy1 := int(src.Y[s10i]) * 0x10101 - s10cb1 := int(src.Cb[s10j]) - 128 - s10cr1 := int(src.Cr[s10j]) - 128 - s10ru := (s10yy1 + 91881*s10cr1) >> 8 - s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 - s10bu := (s10yy1 + 116130*s10cb1) >> 8 - if s10ru < 0 { - s10ru = 0 - } else if s10ru > 0xffff { - s10ru = 0xffff - } - if s10gu < 0 { - s10gu = 0 - } else if s10gu > 0xffff { - s10gu = 0xffff - } - if s10bu < 0 { - s10bu = 0 - } else if s10bu > 0xffff { - s10bu = 0xffff - } - - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s01i := (sy1-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) - s01j := (sy1-src.Rect.Min.Y)*src.CStride + ((sx0)/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s01yy1 := int(src.Y[s01i]) * 0x10101 - s01cb1 := int(src.Cb[s01j]) - 128 - s01cr1 := int(src.Cr[s01j]) - 128 - s01ru := (s01yy1 + 91881*s01cr1) >> 8 - s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 - s01bu := (s01yy1 + 116130*s01cb1) >> 8 - if s01ru < 0 { - s01ru = 0 - } else if s01ru > 0xffff { - s01ru = 0xffff - } - if s01gu < 0 { - s01gu = 0 - } else if s01gu > 0xffff { - s01gu = 0xffff - } - if s01bu < 0 { - s01bu = 0 - } else if s01bu > 0xffff { - s01bu = 0xffff - } - - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s11i := (sy1-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) - s11j := (sy1-src.Rect.Min.Y)*src.CStride + ((sx1)/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s11yy1 := int(src.Y[s11i]) * 0x10101 - s11cb1 := int(src.Cb[s11j]) - 128 - s11cr1 := int(src.Cr[s11j]) - 128 - s11ru := (s11yy1 + 91881*s11cr1) >> 8 - s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 - s11bu := (s11yy1 + 116130*s11cb1) >> 8 - if s11ru < 0 { - s11ru = 0 - } else if s11ru > 0xffff { - s11ru = 0xffff - } - if s11gu < 0 { - s11gu = 0 - } else if s11gu > 0xffff { - s11gu = 0xffff - } - if s11bu < 0 { - s11bu = 0 - } else if s11bu > 0xffff { - s11bu = 0xffff - } - - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (ablInterpolator) transform_RGBA_YCbCr420_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - sx -= 0.5 - sx0 := int(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx0 += bias.X - sx1 := sx0 + 1 - if sx0 < sr.Min.X { - sx0, sx1 = sr.Min.X, sr.Min.X - xFrac0, xFrac1 = 0, 1 - } else if sx1 >= sr.Max.X { - sx0, sx1 = sr.Max.X-1, sr.Max.X-1 - xFrac0, xFrac1 = 1, 0 - } - - sy -= 0.5 - sy0 := int(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy0 += bias.Y - sy1 := sy0 + 1 - if sy0 < sr.Min.Y { - sy0, sy1 = sr.Min.Y, sr.Min.Y - yFrac0, yFrac1 = 0, 1 - } else if sy1 >= sr.Max.Y { - sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 - yFrac0, yFrac1 = 1, 0 - } - - s00i := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) - s00j := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + ((sx0)/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s00yy1 := int(src.Y[s00i]) * 0x10101 - s00cb1 := int(src.Cb[s00j]) - 128 - s00cr1 := int(src.Cr[s00j]) - 128 - s00ru := (s00yy1 + 91881*s00cr1) >> 8 - s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 - s00bu := (s00yy1 + 116130*s00cb1) >> 8 - if s00ru < 0 { - s00ru = 0 - } else if s00ru > 0xffff { - s00ru = 0xffff - } - if s00gu < 0 { - s00gu = 0 - } else if s00gu > 0xffff { - s00gu = 0xffff - } - if s00bu < 0 { - s00bu = 0 - } else if s00bu > 0xffff { - s00bu = 0xffff - } - - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s10i := (sy0-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) - s10j := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + ((sx1)/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s10yy1 := int(src.Y[s10i]) * 0x10101 - s10cb1 := int(src.Cb[s10j]) - 128 - s10cr1 := int(src.Cr[s10j]) - 128 - s10ru := (s10yy1 + 91881*s10cr1) >> 8 - s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 - s10bu := (s10yy1 + 116130*s10cb1) >> 8 - if s10ru < 0 { - s10ru = 0 - } else if s10ru > 0xffff { - s10ru = 0xffff - } - if s10gu < 0 { - s10gu = 0 - } else if s10gu > 0xffff { - s10gu = 0xffff - } - if s10bu < 0 { - s10bu = 0 - } else if s10bu > 0xffff { - s10bu = 0xffff - } - - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s01i := (sy1-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) - s01j := ((sy1)/2-src.Rect.Min.Y/2)*src.CStride + ((sx0)/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s01yy1 := int(src.Y[s01i]) * 0x10101 - s01cb1 := int(src.Cb[s01j]) - 128 - s01cr1 := int(src.Cr[s01j]) - 128 - s01ru := (s01yy1 + 91881*s01cr1) >> 8 - s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 - s01bu := (s01yy1 + 116130*s01cb1) >> 8 - if s01ru < 0 { - s01ru = 0 - } else if s01ru > 0xffff { - s01ru = 0xffff - } - if s01gu < 0 { - s01gu = 0 - } else if s01gu > 0xffff { - s01gu = 0xffff - } - if s01bu < 0 { - s01bu = 0 - } else if s01bu > 0xffff { - s01bu = 0xffff - } - - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s11i := (sy1-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) - s11j := ((sy1)/2-src.Rect.Min.Y/2)*src.CStride + ((sx1)/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s11yy1 := int(src.Y[s11i]) * 0x10101 - s11cb1 := int(src.Cb[s11j]) - 128 - s11cr1 := int(src.Cr[s11j]) - 128 - s11ru := (s11yy1 + 91881*s11cr1) >> 8 - s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 - s11bu := (s11yy1 + 116130*s11cb1) >> 8 - if s11ru < 0 { - s11ru = 0 - } else if s11ru > 0xffff { - s11ru = 0xffff - } - if s11gu < 0 { - s11gu = 0 - } else if s11gu > 0xffff { - s11gu = 0xffff - } - if s11bu < 0 { - s11bu = 0 - } else if s11bu > 0xffff { - s11bu = 0xffff - } - - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (ablInterpolator) transform_RGBA_YCbCr440_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - sx -= 0.5 - sx0 := int(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx0 += bias.X - sx1 := sx0 + 1 - if sx0 < sr.Min.X { - sx0, sx1 = sr.Min.X, sr.Min.X - xFrac0, xFrac1 = 0, 1 - } else if sx1 >= sr.Max.X { - sx0, sx1 = sr.Max.X-1, sr.Max.X-1 - xFrac0, xFrac1 = 1, 0 - } - - sy -= 0.5 - sy0 := int(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy0 += bias.Y - sy1 := sy0 + 1 - if sy0 < sr.Min.Y { - sy0, sy1 = sr.Min.Y, sr.Min.Y - yFrac0, yFrac1 = 0, 1 - } else if sy1 >= sr.Max.Y { - sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 - yFrac0, yFrac1 = 1, 0 - } - - s00i := (sy0-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) - s00j := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + (sx0 - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s00yy1 := int(src.Y[s00i]) * 0x10101 - s00cb1 := int(src.Cb[s00j]) - 128 - s00cr1 := int(src.Cr[s00j]) - 128 - s00ru := (s00yy1 + 91881*s00cr1) >> 8 - s00gu := (s00yy1 - 22554*s00cb1 - 46802*s00cr1) >> 8 - s00bu := (s00yy1 + 116130*s00cb1) >> 8 - if s00ru < 0 { - s00ru = 0 - } else if s00ru > 0xffff { - s00ru = 0xffff - } - if s00gu < 0 { - s00gu = 0 - } else if s00gu > 0xffff { - s00gu = 0xffff - } - if s00bu < 0 { - s00bu = 0 - } else if s00bu > 0xffff { - s00bu = 0xffff - } - - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s10i := (sy0-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) - s10j := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + (sx1 - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s10yy1 := int(src.Y[s10i]) * 0x10101 - s10cb1 := int(src.Cb[s10j]) - 128 - s10cr1 := int(src.Cr[s10j]) - 128 - s10ru := (s10yy1 + 91881*s10cr1) >> 8 - s10gu := (s10yy1 - 22554*s10cb1 - 46802*s10cr1) >> 8 - s10bu := (s10yy1 + 116130*s10cb1) >> 8 - if s10ru < 0 { - s10ru = 0 - } else if s10ru > 0xffff { - s10ru = 0xffff - } - if s10gu < 0 { - s10gu = 0 - } else if s10gu > 0xffff { - s10gu = 0xffff - } - if s10bu < 0 { - s10bu = 0 - } else if s10bu > 0xffff { - s10bu = 0xffff - } - - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s01i := (sy1-src.Rect.Min.Y)*src.YStride + (sx0 - src.Rect.Min.X) - s01j := ((sy1)/2-src.Rect.Min.Y/2)*src.CStride + (sx0 - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s01yy1 := int(src.Y[s01i]) * 0x10101 - s01cb1 := int(src.Cb[s01j]) - 128 - s01cr1 := int(src.Cr[s01j]) - 128 - s01ru := (s01yy1 + 91881*s01cr1) >> 8 - s01gu := (s01yy1 - 22554*s01cb1 - 46802*s01cr1) >> 8 - s01bu := (s01yy1 + 116130*s01cb1) >> 8 - if s01ru < 0 { - s01ru = 0 - } else if s01ru > 0xffff { - s01ru = 0xffff - } - if s01gu < 0 { - s01gu = 0 - } else if s01gu > 0xffff { - s01gu = 0xffff - } - if s01bu < 0 { - s01bu = 0 - } else if s01bu > 0xffff { - s01bu = 0xffff - } - - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s11i := (sy1-src.Rect.Min.Y)*src.YStride + (sx1 - src.Rect.Min.X) - s11j := ((sy1)/2-src.Rect.Min.Y/2)*src.CStride + (sx1 - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - s11yy1 := int(src.Y[s11i]) * 0x10101 - s11cb1 := int(src.Cb[s11j]) - 128 - s11cr1 := int(src.Cr[s11j]) - 128 - s11ru := (s11yy1 + 91881*s11cr1) >> 8 - s11gu := (s11yy1 - 22554*s11cb1 - 46802*s11cr1) >> 8 - s11bu := (s11yy1 + 116130*s11cb1) >> 8 - if s11ru < 0 { - s11ru = 0 - } else if s11ru > 0xffff { - s11ru = 0xffff - } - if s11gu < 0 { - s11gu = 0 - } else if s11gu > 0xffff { - s11gu = 0xffff - } - if s11bu < 0 { - s11bu = 0 - } else if s11bu > 0xffff { - s11bu = 0xffff - } - - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (ablInterpolator) transform_RGBA_Image_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - sx -= 0.5 - sx0 := int(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx0 += bias.X - sx1 := sx0 + 1 - if sx0 < sr.Min.X { - sx0, sx1 = sr.Min.X, sr.Min.X - xFrac0, xFrac1 = 0, 1 - } else if sx1 >= sr.Max.X { - sx0, sx1 = sr.Max.X-1, sr.Max.X-1 - xFrac0, xFrac1 = 1, 0 - } - - sy -= 0.5 - sy0 := int(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy0 += bias.Y - sy1 := sy0 + 1 - if sy0 < sr.Min.Y { - sy0, sy1 = sr.Min.Y, sr.Min.Y - yFrac0, yFrac1 = 0, 1 - } else if sy1 >= sr.Max.Y { - sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 - yFrac0, yFrac1 = 1, 0 - } - - s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA() - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA() - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA() - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA() - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - pa1 := (0xffff - pa) * 0x101 - 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) - } - } -} - -func (ablInterpolator) transform_RGBA_Image_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - sx -= 0.5 - sx0 := int(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx0 += bias.X - sx1 := sx0 + 1 - if sx0 < sr.Min.X { - sx0, sx1 = sr.Min.X, sr.Min.X - xFrac0, xFrac1 = 0, 1 - } else if sx1 >= sr.Max.X { - sx0, sx1 = sr.Max.X-1, sr.Max.X-1 - xFrac0, xFrac1 = 1, 0 - } - - sy -= 0.5 - sy0 := int(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy0 += bias.Y - sy1 := sy0 + 1 - if sy0 < sr.Min.Y { - sy0, sy1 = sr.Min.Y, sr.Min.Y - yFrac0, yFrac1 = 0, 1 - } else if sy1 >= sr.Max.Y { - sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 - yFrac0, yFrac1 = 1, 0 - } - - s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA() - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA() - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA() - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA() - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - dst.Pix[d+0] = uint8(pr >> 8) - dst.Pix[d+1] = uint8(pg >> 8) - dst.Pix[d+2] = uint8(pb >> 8) - dst.Pix[d+3] = uint8(pa >> 8) - } - } -} - -func (ablInterpolator) transform_Image_Image_Over(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { - srcMask, smp := opts.SrcMask, opts.SrcMaskP - dstMask, dmp := opts.DstMask, opts.DstMaskP - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - sx -= 0.5 - sx0 := int(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx0 += bias.X - sx1 := sx0 + 1 - if sx0 < sr.Min.X { - sx0, sx1 = sr.Min.X, sr.Min.X - xFrac0, xFrac1 = 0, 1 - } else if sx1 >= sr.Max.X { - sx0, sx1 = sr.Max.X-1, sr.Max.X-1 - xFrac0, xFrac1 = 1, 0 - } - - sy -= 0.5 - sy0 := int(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy0 += bias.Y - sy1 := sy0 + 1 - if sy0 < sr.Min.Y { - sy0, sy1 = sr.Min.Y, sr.Min.Y - yFrac0, yFrac1 = 0, 1 - } else if sy1 >= sr.Max.Y { - sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 - yFrac0, yFrac1 = 1, 0 - } - - s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sx0, smp.Y+sy0).RGBA() - s00ru = s00ru * ma / 0xffff - s00gu = s00gu * ma / 0xffff - s00bu = s00bu * ma / 0xffff - s00au = s00au * ma / 0xffff - } - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sx1, smp.Y+sy0).RGBA() - s10ru = s10ru * ma / 0xffff - s10gu = s10gu * ma / 0xffff - s10bu = s10bu * ma / 0xffff - s10au = s10au * ma / 0xffff - } - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sx0, smp.Y+sy1).RGBA() - s01ru = s01ru * ma / 0xffff - s01gu = s01gu * ma / 0xffff - s01bu = s01bu * ma / 0xffff - s01au = s01au * ma / 0xffff - } - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sx1, smp.Y+sy1).RGBA() - s11ru = s11ru * ma / 0xffff - s11gu = s11gu * ma / 0xffff - s11bu = s11bu * ma / 0xffff - s11au = s11au * ma / 0xffff - } - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() - if dstMask != nil { - _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() - pr = pr * ma / 0xffff - pg = pg * ma / 0xffff - pb = pb * ma / 0xffff - pa = pa * ma / 0xffff - } - pa1 := 0xffff - pa - 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) - } - } -} - -func (ablInterpolator) transform_Image_Image_Src(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, opts *Options) { - srcMask, smp := opts.SrcMask, opts.SrcMaskP - dstMask, dmp := opts.DstMask, opts.DstMaskP - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - sx -= 0.5 - sx0 := int(sx) - xFrac0 := sx - float64(sx0) - xFrac1 := 1 - xFrac0 - sx0 += bias.X - sx1 := sx0 + 1 - if sx0 < sr.Min.X { - sx0, sx1 = sr.Min.X, sr.Min.X - xFrac0, xFrac1 = 0, 1 - } else if sx1 >= sr.Max.X { - sx0, sx1 = sr.Max.X-1, sr.Max.X-1 - xFrac0, xFrac1 = 1, 0 - } - - sy -= 0.5 - sy0 := int(sy) - yFrac0 := sy - float64(sy0) - yFrac1 := 1 - yFrac0 - sy0 += bias.Y - sy1 := sy0 + 1 - if sy0 < sr.Min.Y { - sy0, sy1 = sr.Min.Y, sr.Min.Y - yFrac0, yFrac1 = 0, 1 - } else if sy1 >= sr.Max.Y { - sy0, sy1 = sr.Max.Y-1, sr.Max.Y-1 - yFrac0, yFrac1 = 1, 0 - } - - s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sx0, smp.Y+sy0).RGBA() - s00ru = s00ru * ma / 0xffff - s00gu = s00gu * ma / 0xffff - s00bu = s00bu * ma / 0xffff - s00au = s00au * ma / 0xffff - } - s00r := float64(s00ru) - s00g := float64(s00gu) - s00b := float64(s00bu) - s00a := float64(s00au) - s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sx1, smp.Y+sy0).RGBA() - s10ru = s10ru * ma / 0xffff - s10gu = s10gu * ma / 0xffff - s10bu = s10bu * ma / 0xffff - s10au = s10au * ma / 0xffff - } - s10r := float64(s10ru) - s10g := float64(s10gu) - s10b := float64(s10bu) - s10a := float64(s10au) - s10r = xFrac1*s00r + xFrac0*s10r - s10g = xFrac1*s00g + xFrac0*s10g - s10b = xFrac1*s00b + xFrac0*s10b - s10a = xFrac1*s00a + xFrac0*s10a - s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sx0, smp.Y+sy1).RGBA() - s01ru = s01ru * ma / 0xffff - s01gu = s01gu * ma / 0xffff - s01bu = s01bu * ma / 0xffff - s01au = s01au * ma / 0xffff - } - s01r := float64(s01ru) - s01g := float64(s01gu) - s01b := float64(s01bu) - s01a := float64(s01au) - s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sx1, smp.Y+sy1).RGBA() - s11ru = s11ru * ma / 0xffff - s11gu = s11gu * ma / 0xffff - s11bu = s11bu * ma / 0xffff - s11au = s11au * ma / 0xffff - } - s11r := float64(s11ru) - s11g := float64(s11gu) - s11b := float64(s11bu) - s11a := float64(s11au) - s11r = xFrac1*s01r + xFrac0*s11r - s11g = xFrac1*s01g + xFrac0*s11g - s11b = xFrac1*s01b + xFrac0*s11b - s11a = xFrac1*s01a + xFrac0*s11a - s11r = yFrac1*s10r + yFrac0*s11r - s11g = yFrac1*s10g + yFrac0*s11g - s11b = yFrac1*s10b + yFrac0*s11b - s11a = yFrac1*s10a + yFrac0*s11a - pr := uint32(s11r) - pg := uint32(s11g) - pb := uint32(s11b) - pa := uint32(s11a) - if dstMask != nil { - qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() - _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() - pr = pr * ma / 0xffff - pg = pg * ma / 0xffff - pb = pb * ma / 0xffff - pa = pa * ma / 0xffff - pa1 := 0xffff - ma - 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) - } else { - dstColorRGBA64.R = uint16(pr) - dstColorRGBA64.G = uint16(pg) - dstColorRGBA64.B = uint16(pb) - dstColorRGBA64.A = uint16(pa) - dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) - } - } - } -} - -func (z *kernelScaler) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) { - if z.dw != int32(dr.Dx()) || z.dh != int32(dr.Dy()) || z.sw != int32(sr.Dx()) || z.sh != int32(sr.Dy()) { - z.kernel.Scale(dst, dr, src, sr, op, opts) - return - } - - var o Options - if opts != nil { - o = *opts - } - - // adr is the affected destination pixels. - adr := dst.Bounds().Intersect(dr) - adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) - if adr.Empty() || sr.Empty() { - return - } - // Make adr relative to dr.Min. - adr = adr.Sub(dr.Min) - if op == Over && o.SrcMask == nil && opaque(src) { - op = Src - } - - if _, ok := src.(*image.Uniform); ok && o.DstMask == nil && o.SrcMask == nil && sr.In(src.Bounds()) { - Draw(dst, dr, src, src.Bounds().Min, op) - return - } - - // Create a temporary buffer: - // scaleX distributes the source image's columns over the temporary image. - // scaleY distributes the temporary image's rows over the destination image. - var tmp [][4]float64 - if z.pool.New != nil { - tmpp := z.pool.Get().(*[][4]float64) - defer z.pool.Put(tmpp) - tmp = *tmpp - } else { - tmp = z.makeTmpBuf() - } - - // sr is the source pixels. If it extends beyond the src bounds, - // we cannot use the type-specific fast paths, as they access - // the Pix fields directly without bounds checking. - // - // Similarly, the fast paths assume that the masks are nil. - if o.SrcMask != nil || !sr.In(src.Bounds()) { - z.scaleX_Image(tmp, src, sr, &o) - } else { - switch src := src.(type) { - case *image.Gray: - z.scaleX_Gray(tmp, src, sr, &o) - case *image.NRGBA: - z.scaleX_NRGBA(tmp, src, sr, &o) - case *image.RGBA: - z.scaleX_RGBA(tmp, src, sr, &o) - case *image.YCbCr: - switch src.SubsampleRatio { - default: - z.scaleX_Image(tmp, src, sr, &o) - case image.YCbCrSubsampleRatio444: - z.scaleX_YCbCr444(tmp, src, sr, &o) - case image.YCbCrSubsampleRatio422: - z.scaleX_YCbCr422(tmp, src, sr, &o) - case image.YCbCrSubsampleRatio420: - z.scaleX_YCbCr420(tmp, src, sr, &o) - case image.YCbCrSubsampleRatio440: - z.scaleX_YCbCr440(tmp, src, sr, &o) - } - default: - z.scaleX_Image(tmp, src, sr, &o) - } - } - - if o.DstMask != nil { - switch op { - case Over: - z.scaleY_Image_Over(dst, dr, adr, tmp, &o) - case Src: - z.scaleY_Image_Src(dst, dr, adr, tmp, &o) - } - } else { - switch op { - case Over: - switch dst := dst.(type) { - case *image.RGBA: - z.scaleY_RGBA_Over(dst, dr, adr, tmp, &o) - default: - z.scaleY_Image_Over(dst, dr, adr, tmp, &o) - } - case Src: - switch dst := dst.(type) { - case *image.RGBA: - z.scaleY_RGBA_Src(dst, dr, adr, tmp, &o) - default: - z.scaleY_Image_Src(dst, dr, adr, tmp, &o) - } - } - } -} - -func (q *Kernel) Transform(dst Image, s2d f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options) { - var o Options - if opts != nil { - o = *opts - } - - dr := transformRect(&s2d, &sr) - // adr is the affected destination pixels. - adr := dst.Bounds().Intersect(dr) - adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP) - if adr.Empty() || sr.Empty() { - return - } - if op == Over && o.SrcMask == nil && opaque(src) { - op = Src - } - d2s := invert(&s2d) - // bias is a translation of the mapping from dst coordinates to src - // coordinates such that the latter temporarily have non-negative X - // and Y coordinates. This allows us to write int(f) instead of - // int(math.Floor(f)), since "round to zero" and "round down" are - // equivalent when f >= 0, but the former is much cheaper. The X-- - // and Y-- are because the TransformLeaf methods have a "sx -= 0.5" - // adjustment. - bias := transformRect(&d2s, &adr).Min - bias.X-- - bias.Y-- - d2s[2] -= float64(bias.X) - d2s[5] -= float64(bias.Y) - // Make adr relative to dr.Min. - adr = adr.Sub(dr.Min) - - if u, ok := src.(*image.Uniform); ok && o.DstMask != nil && o.SrcMask != nil && sr.In(src.Bounds()) { - transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, op) - return - } - - xscale := abs(d2s[0]) - if s := abs(d2s[1]); xscale < s { - xscale = s - } - yscale := abs(d2s[3]) - if s := abs(d2s[4]); yscale < s { - yscale = s - } - - // sr is the source pixels. If it extends beyond the src bounds, - // we cannot use the type-specific fast paths, as they access - // the Pix fields directly without bounds checking. - // - // Similarly, the fast paths assume that the masks are nil. - if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) { - switch op { - case Over: - q.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - case Src: - q.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - } - } else { - switch op { - case Over: - switch dst := dst.(type) { - case *image.RGBA: - switch src := src.(type) { - case *image.NRGBA: - q.transform_RGBA_NRGBA_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - case *image.RGBA: - q.transform_RGBA_RGBA_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - default: - q.transform_RGBA_Image_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - } - default: - switch src := src.(type) { - default: - q.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - } - } - case Src: - switch dst := dst.(type) { - case *image.RGBA: - switch src := src.(type) { - case *image.Gray: - q.transform_RGBA_Gray_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - case *image.NRGBA: - q.transform_RGBA_NRGBA_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - case *image.RGBA: - q.transform_RGBA_RGBA_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - case *image.YCbCr: - switch src.SubsampleRatio { - default: - q.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - case image.YCbCrSubsampleRatio444: - q.transform_RGBA_YCbCr444_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - case image.YCbCrSubsampleRatio422: - q.transform_RGBA_YCbCr422_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - case image.YCbCrSubsampleRatio420: - q.transform_RGBA_YCbCr420_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - case image.YCbCrSubsampleRatio440: - q.transform_RGBA_YCbCr440_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - } - default: - q.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - } - default: - switch src := src.(type) { - default: - q.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o) - } - } - } - } -} - -func (z *kernelScaler) scaleX_Gray(tmp [][4]float64, src *image.Gray, sr image.Rectangle, opts *Options) { - t := 0 - for y := int32(0); y < z.sh; y++ { - for _, s := range z.horizontal.sources { - var pr float64 - for _, c := range z.horizontal.contribs[s.i:s.j] { - pi := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(c.coord) - src.Rect.Min.X) - pru := uint32(src.Pix[pi]) * 0x101 - pr += float64(pru) * c.weight - } - pr *= s.invTotalWeightFFFF - tmp[t] = [4]float64{ - pr, - pr, - pr, - 1, - } - t++ - } - } -} - -func (z *kernelScaler) scaleX_NRGBA(tmp [][4]float64, src *image.NRGBA, sr image.Rectangle, opts *Options) { - t := 0 - for y := int32(0); y < z.sh; y++ { - for _, s := range z.horizontal.sources { - var pr, pg, pb, pa float64 - for _, c := range z.horizontal.contribs[s.i:s.j] { - pi := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(c.coord)-src.Rect.Min.X)*4 - pau := uint32(src.Pix[pi+3]) * 0x101 - pru := uint32(src.Pix[pi+0]) * pau / 0xff - pgu := uint32(src.Pix[pi+1]) * pau / 0xff - pbu := uint32(src.Pix[pi+2]) * pau / 0xff - pr += float64(pru) * c.weight - pg += float64(pgu) * c.weight - pb += float64(pbu) * c.weight - pa += float64(pau) * c.weight - } - tmp[t] = [4]float64{ - pr * s.invTotalWeightFFFF, - pg * s.invTotalWeightFFFF, - pb * s.invTotalWeightFFFF, - pa * s.invTotalWeightFFFF, - } - t++ - } - } -} - -func (z *kernelScaler) scaleX_RGBA(tmp [][4]float64, src *image.RGBA, sr image.Rectangle, opts *Options) { - t := 0 - for y := int32(0); y < z.sh; y++ { - for _, s := range z.horizontal.sources { - var pr, pg, pb, pa float64 - for _, c := range z.horizontal.contribs[s.i:s.j] { - pi := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(c.coord)-src.Rect.Min.X)*4 - pru := uint32(src.Pix[pi+0]) * 0x101 - pgu := uint32(src.Pix[pi+1]) * 0x101 - pbu := uint32(src.Pix[pi+2]) * 0x101 - pau := uint32(src.Pix[pi+3]) * 0x101 - pr += float64(pru) * c.weight - pg += float64(pgu) * c.weight - pb += float64(pbu) * c.weight - pa += float64(pau) * c.weight - } - tmp[t] = [4]float64{ - pr * s.invTotalWeightFFFF, - pg * s.invTotalWeightFFFF, - pb * s.invTotalWeightFFFF, - pa * s.invTotalWeightFFFF, - } - t++ - } - } -} - -func (z *kernelScaler) scaleX_YCbCr444(tmp [][4]float64, src *image.YCbCr, sr image.Rectangle, opts *Options) { - t := 0 - for y := int32(0); y < z.sh; y++ { - for _, s := range z.horizontal.sources { - var pr, pg, pb float64 - for _, c := range z.horizontal.contribs[s.i:s.j] { - pi := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(c.coord) - src.Rect.Min.X) - pj := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.CStride + (sr.Min.X + int(c.coord) - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pru := (pyy1 + 91881*pcr1) >> 8 - pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pbu := (pyy1 + 116130*pcb1) >> 8 - if pru < 0 { - pru = 0 - } else if pru > 0xffff { - pru = 0xffff - } - if pgu < 0 { - pgu = 0 - } else if pgu > 0xffff { - pgu = 0xffff - } - if pbu < 0 { - pbu = 0 - } else if pbu > 0xffff { - pbu = 0xffff - } - - pr += float64(pru) * c.weight - pg += float64(pgu) * c.weight - pb += float64(pbu) * c.weight - } - tmp[t] = [4]float64{ - pr * s.invTotalWeightFFFF, - pg * s.invTotalWeightFFFF, - pb * s.invTotalWeightFFFF, - 1, - } - t++ - } - } -} - -func (z *kernelScaler) scaleX_YCbCr422(tmp [][4]float64, src *image.YCbCr, sr image.Rectangle, opts *Options) { - t := 0 - for y := int32(0); y < z.sh; y++ { - for _, s := range z.horizontal.sources { - var pr, pg, pb float64 - for _, c := range z.horizontal.contribs[s.i:s.j] { - pi := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(c.coord) - src.Rect.Min.X) - pj := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.CStride + ((sr.Min.X+int(c.coord))/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pru := (pyy1 + 91881*pcr1) >> 8 - pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pbu := (pyy1 + 116130*pcb1) >> 8 - if pru < 0 { - pru = 0 - } else if pru > 0xffff { - pru = 0xffff - } - if pgu < 0 { - pgu = 0 - } else if pgu > 0xffff { - pgu = 0xffff - } - if pbu < 0 { - pbu = 0 - } else if pbu > 0xffff { - pbu = 0xffff - } - - pr += float64(pru) * c.weight - pg += float64(pgu) * c.weight - pb += float64(pbu) * c.weight - } - tmp[t] = [4]float64{ - pr * s.invTotalWeightFFFF, - pg * s.invTotalWeightFFFF, - pb * s.invTotalWeightFFFF, - 1, - } - t++ - } - } -} - -func (z *kernelScaler) scaleX_YCbCr420(tmp [][4]float64, src *image.YCbCr, sr image.Rectangle, opts *Options) { - t := 0 - for y := int32(0); y < z.sh; y++ { - for _, s := range z.horizontal.sources { - var pr, pg, pb float64 - for _, c := range z.horizontal.contribs[s.i:s.j] { - pi := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(c.coord) - src.Rect.Min.X) - pj := ((sr.Min.Y+int(y))/2-src.Rect.Min.Y/2)*src.CStride + ((sr.Min.X+int(c.coord))/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pru := (pyy1 + 91881*pcr1) >> 8 - pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pbu := (pyy1 + 116130*pcb1) >> 8 - if pru < 0 { - pru = 0 - } else if pru > 0xffff { - pru = 0xffff - } - if pgu < 0 { - pgu = 0 - } else if pgu > 0xffff { - pgu = 0xffff - } - if pbu < 0 { - pbu = 0 - } else if pbu > 0xffff { - pbu = 0xffff - } - - pr += float64(pru) * c.weight - pg += float64(pgu) * c.weight - pb += float64(pbu) * c.weight - } - tmp[t] = [4]float64{ - pr * s.invTotalWeightFFFF, - pg * s.invTotalWeightFFFF, - pb * s.invTotalWeightFFFF, - 1, - } - t++ - } - } -} - -func (z *kernelScaler) scaleX_YCbCr440(tmp [][4]float64, src *image.YCbCr, sr image.Rectangle, opts *Options) { - t := 0 - for y := int32(0); y < z.sh; y++ { - for _, s := range z.horizontal.sources { - var pr, pg, pb float64 - for _, c := range z.horizontal.contribs[s.i:s.j] { - pi := (sr.Min.Y+int(y)-src.Rect.Min.Y)*src.YStride + (sr.Min.X + int(c.coord) - src.Rect.Min.X) - pj := ((sr.Min.Y+int(y))/2-src.Rect.Min.Y/2)*src.CStride + (sr.Min.X + int(c.coord) - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pru := (pyy1 + 91881*pcr1) >> 8 - pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pbu := (pyy1 + 116130*pcb1) >> 8 - if pru < 0 { - pru = 0 - } else if pru > 0xffff { - pru = 0xffff - } - if pgu < 0 { - pgu = 0 - } else if pgu > 0xffff { - pgu = 0xffff - } - if pbu < 0 { - pbu = 0 - } else if pbu > 0xffff { - pbu = 0xffff - } - - pr += float64(pru) * c.weight - pg += float64(pgu) * c.weight - pb += float64(pbu) * c.weight - } - tmp[t] = [4]float64{ - pr * s.invTotalWeightFFFF, - pg * s.invTotalWeightFFFF, - pb * s.invTotalWeightFFFF, - 1, - } - t++ - } - } -} - -func (z *kernelScaler) scaleX_Image(tmp [][4]float64, src image.Image, sr image.Rectangle, opts *Options) { - t := 0 - srcMask, smp := opts.SrcMask, opts.SrcMaskP - for y := int32(0); y < z.sh; y++ { - for _, s := range z.horizontal.sources { - var pr, pg, pb, pa float64 - for _, c := range z.horizontal.contribs[s.i:s.j] { - pru, pgu, pbu, pau := src.At(sr.Min.X+int(c.coord), sr.Min.Y+int(y)).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+sr.Min.X+int(c.coord), smp.Y+sr.Min.Y+int(y)).RGBA() - pru = pru * ma / 0xffff - pgu = pgu * ma / 0xffff - pbu = pbu * ma / 0xffff - pau = pau * ma / 0xffff - } - pr += float64(pru) * c.weight - pg += float64(pgu) * c.weight - pb += float64(pbu) * c.weight - pa += float64(pau) * c.weight - } - tmp[t] = [4]float64{ - pr * s.invTotalWeightFFFF, - pg * s.invTotalWeightFFFF, - pb * s.invTotalWeightFFFF, - pa * s.invTotalWeightFFFF, - } - t++ - } - } -} - -func (z *kernelScaler) scaleY_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, tmp [][4]float64, opts *Options) { - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - d := (dr.Min.Y+adr.Min.Y-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+int(dx)-dst.Rect.Min.X)*4 - for _, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] { - var pr, pg, pb, pa float64 - for _, c := range z.vertical.contribs[s.i:s.j] { - p := &tmp[c.coord*z.dw+dx] - pr += p[0] * c.weight - pg += p[1] * c.weight - pb += p[2] * c.weight - pa += p[3] * c.weight - } - - if pr > pa { - pr = pa - } - if pg > pa { - pg = pa - } - if pb > pa { - pb = pa - } - - pr0 := uint32(ftou(pr * s.invTotalWeight)) - pg0 := uint32(ftou(pg * s.invTotalWeight)) - pb0 := uint32(ftou(pb * s.invTotalWeight)) - pa0 := uint32(ftou(pa * s.invTotalWeight)) - pa1 := (0xffff - uint32(pa0)) * 0x101 - dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr0) >> 8) - dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg0) >> 8) - dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb0) >> 8) - dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa0) >> 8) - d += dst.Stride - } - } -} - -func (z *kernelScaler) scaleY_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, tmp [][4]float64, opts *Options) { - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - d := (dr.Min.Y+adr.Min.Y-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+int(dx)-dst.Rect.Min.X)*4 - for _, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] { - var pr, pg, pb, pa float64 - for _, c := range z.vertical.contribs[s.i:s.j] { - p := &tmp[c.coord*z.dw+dx] - pr += p[0] * c.weight - pg += p[1] * c.weight - pb += p[2] * c.weight - pa += p[3] * c.weight - } - - if pr > pa { - pr = pa - } - if pg > pa { - pg = pa - } - if pb > pa { - pb = pa - } - - dst.Pix[d+0] = uint8(ftou(pr*s.invTotalWeight) >> 8) - dst.Pix[d+1] = uint8(ftou(pg*s.invTotalWeight) >> 8) - dst.Pix[d+2] = uint8(ftou(pb*s.invTotalWeight) >> 8) - dst.Pix[d+3] = uint8(ftou(pa*s.invTotalWeight) >> 8) - d += dst.Stride - } - } -} - -func (z *kernelScaler) scaleY_Image_Over(dst Image, dr, adr image.Rectangle, tmp [][4]float64, opts *Options) { - dstMask, dmp := opts.DstMask, opts.DstMaskP - dstColorRGBA64 := &color.RGBA64{} - dstColor := color.Color(dstColorRGBA64) - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - for dy, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] { - var pr, pg, pb, pa float64 - for _, c := range z.vertical.contribs[s.i:s.j] { - p := &tmp[c.coord*z.dw+dx] - pr += p[0] * c.weight - pg += p[1] * c.weight - pb += p[2] * c.weight - pa += p[3] * c.weight - } - - if pr > pa { - pr = pa - } - if pg > pa { - pg = pa - } - if pb > pa { - pb = pa - } - - qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(adr.Min.Y+dy)).RGBA() - pr0 := uint32(ftou(pr * s.invTotalWeight)) - pg0 := uint32(ftou(pg * s.invTotalWeight)) - pb0 := uint32(ftou(pb * s.invTotalWeight)) - pa0 := uint32(ftou(pa * s.invTotalWeight)) - if dstMask != nil { - _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(adr.Min.Y+dy)).RGBA() - pr0 = pr0 * ma / 0xffff - pg0 = pg0 * ma / 0xffff - pb0 = pb0 * ma / 0xffff - pa0 = pa0 * ma / 0xffff - } - pa1 := 0xffff - pa0 - dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr0) - dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg0) - dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb0) - dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa0) - dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(adr.Min.Y+dy), dstColor) - } - } -} - -func (z *kernelScaler) scaleY_Image_Src(dst Image, dr, adr image.Rectangle, tmp [][4]float64, opts *Options) { - dstMask, dmp := opts.DstMask, opts.DstMaskP - dstColorRGBA64 := &color.RGBA64{} - dstColor := color.Color(dstColorRGBA64) - for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ { - for dy, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] { - var pr, pg, pb, pa float64 - for _, c := range z.vertical.contribs[s.i:s.j] { - p := &tmp[c.coord*z.dw+dx] - pr += p[0] * c.weight - pg += p[1] * c.weight - pb += p[2] * c.weight - pa += p[3] * c.weight - } - - if pr > pa { - pr = pa - } - if pg > pa { - pg = pa - } - if pb > pa { - pb = pa - } - - if dstMask != nil { - qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(adr.Min.Y+dy)).RGBA() - _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(adr.Min.Y+dy)).RGBA() - pr := uint32(ftou(pr*s.invTotalWeight)) * ma / 0xffff - pg := uint32(ftou(pg*s.invTotalWeight)) * ma / 0xffff - pb := uint32(ftou(pb*s.invTotalWeight)) * ma / 0xffff - pa := uint32(ftou(pa*s.invTotalWeight)) * ma / 0xffff - pa1 := 0xffff - ma - 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(adr.Min.Y+dy), dstColor) - } else { - dstColorRGBA64.R = ftou(pr * s.invTotalWeight) - dstColorRGBA64.G = ftou(pg * s.invTotalWeight) - dstColorRGBA64.B = ftou(pb * s.invTotalWeight) - dstColorRGBA64.A = ftou(pa * s.invTotalWeight) - dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(adr.Min.Y+dy), dstColor) - } - } - } -} - -func (q *Kernel) transform_RGBA_Gray_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Gray, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { - // When shrinking, broaden the effective kernel support so that we still - // visit every source pixel. - xHalfWidth, xKernelArgScale := q.Support, 1.0 - if xscale > 1 { - xHalfWidth *= xscale - xKernelArgScale = 1 / xscale - } - yHalfWidth, yKernelArgScale := q.Support, 1.0 - if yscale > 1 { - yHalfWidth *= yscale - yKernelArgScale = 1 / yscale - } - - xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) - yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - // TODO: adjust the bias so that we can use int(f) instead - // of math.Floor(f) and math.Ceil(f). - sx += float64(bias.X) - sx -= 0.5 - ix := int(math.Floor(sx - xHalfWidth)) - if ix < sr.Min.X { - ix = sr.Min.X - } - jx := int(math.Ceil(sx + xHalfWidth)) - if jx > sr.Max.X { - jx = sr.Max.X - } - - totalXWeight := 0.0 - for kx := ix; kx < jx; kx++ { - xWeight := 0.0 - if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { - xWeight = q.At(t) - } - xWeights[kx-ix] = xWeight - totalXWeight += xWeight - } - for x := range xWeights[:jx-ix] { - xWeights[x] /= totalXWeight - } - - sy += float64(bias.Y) - sy -= 0.5 - iy := int(math.Floor(sy - yHalfWidth)) - if iy < sr.Min.Y { - iy = sr.Min.Y - } - jy := int(math.Ceil(sy + yHalfWidth)) - if jy > sr.Max.Y { - jy = sr.Max.Y - } - - totalYWeight := 0.0 - for ky := iy; ky < jy; ky++ { - yWeight := 0.0 - if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { - yWeight = q.At(t) - } - yWeights[ky-iy] = yWeight - totalYWeight += yWeight - } - for y := range yWeights[:jy-iy] { - yWeights[y] /= totalYWeight - } - - var pr float64 - for ky := iy; ky < jy; ky++ { - if yWeight := yWeights[ky-iy]; yWeight != 0 { - for kx := ix; kx < jx; kx++ { - if w := xWeights[kx-ix] * yWeight; w != 0 { - pi := (ky-src.Rect.Min.Y)*src.Stride + (kx - src.Rect.Min.X) - pru := uint32(src.Pix[pi]) * 0x101 - pr += float64(pru) * w - } - } - } - } - out := uint8(fffftou(pr) >> 8) - dst.Pix[d+0] = out - dst.Pix[d+1] = out - dst.Pix[d+2] = out - dst.Pix[d+3] = 0xff - } - } -} - -func (q *Kernel) transform_RGBA_NRGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { - // When shrinking, broaden the effective kernel support so that we still - // visit every source pixel. - xHalfWidth, xKernelArgScale := q.Support, 1.0 - if xscale > 1 { - xHalfWidth *= xscale - xKernelArgScale = 1 / xscale - } - yHalfWidth, yKernelArgScale := q.Support, 1.0 - if yscale > 1 { - yHalfWidth *= yscale - yKernelArgScale = 1 / yscale - } - - xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) - yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - // TODO: adjust the bias so that we can use int(f) instead - // of math.Floor(f) and math.Ceil(f). - sx += float64(bias.X) - sx -= 0.5 - ix := int(math.Floor(sx - xHalfWidth)) - if ix < sr.Min.X { - ix = sr.Min.X - } - jx := int(math.Ceil(sx + xHalfWidth)) - if jx > sr.Max.X { - jx = sr.Max.X - } - - totalXWeight := 0.0 - for kx := ix; kx < jx; kx++ { - xWeight := 0.0 - if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { - xWeight = q.At(t) - } - xWeights[kx-ix] = xWeight - totalXWeight += xWeight - } - for x := range xWeights[:jx-ix] { - xWeights[x] /= totalXWeight - } - - sy += float64(bias.Y) - sy -= 0.5 - iy := int(math.Floor(sy - yHalfWidth)) - if iy < sr.Min.Y { - iy = sr.Min.Y - } - jy := int(math.Ceil(sy + yHalfWidth)) - if jy > sr.Max.Y { - jy = sr.Max.Y - } - - totalYWeight := 0.0 - for ky := iy; ky < jy; ky++ { - yWeight := 0.0 - if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { - yWeight = q.At(t) - } - yWeights[ky-iy] = yWeight - totalYWeight += yWeight - } - for y := range yWeights[:jy-iy] { - yWeights[y] /= totalYWeight - } - - var pr, pg, pb, pa float64 - for ky := iy; ky < jy; ky++ { - if yWeight := yWeights[ky-iy]; yWeight != 0 { - for kx := ix; kx < jx; kx++ { - if w := xWeights[kx-ix] * yWeight; w != 0 { - pi := (ky-src.Rect.Min.Y)*src.Stride + (kx-src.Rect.Min.X)*4 - pau := uint32(src.Pix[pi+3]) * 0x101 - pru := uint32(src.Pix[pi+0]) * pau / 0xff - pgu := uint32(src.Pix[pi+1]) * pau / 0xff - pbu := uint32(src.Pix[pi+2]) * pau / 0xff - pr += float64(pru) * w - pg += float64(pgu) * w - pb += float64(pbu) * w - pa += float64(pau) * w - } - } - } - } - - if pr > pa { - pr = pa - } - if pg > pa { - pg = pa - } - if pb > pa { - pb = pa - } - - pr0 := uint32(fffftou(pr)) - pg0 := uint32(fffftou(pg)) - pb0 := uint32(fffftou(pb)) - pa0 := uint32(fffftou(pa)) - pa1 := (0xffff - uint32(pa0)) * 0x101 - dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr0) >> 8) - dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg0) >> 8) - dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb0) >> 8) - dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa0) >> 8) - } - } -} - -func (q *Kernel) transform_RGBA_NRGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { - // When shrinking, broaden the effective kernel support so that we still - // visit every source pixel. - xHalfWidth, xKernelArgScale := q.Support, 1.0 - if xscale > 1 { - xHalfWidth *= xscale - xKernelArgScale = 1 / xscale - } - yHalfWidth, yKernelArgScale := q.Support, 1.0 - if yscale > 1 { - yHalfWidth *= yscale - yKernelArgScale = 1 / yscale - } - - xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) - yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - // TODO: adjust the bias so that we can use int(f) instead - // of math.Floor(f) and math.Ceil(f). - sx += float64(bias.X) - sx -= 0.5 - ix := int(math.Floor(sx - xHalfWidth)) - if ix < sr.Min.X { - ix = sr.Min.X - } - jx := int(math.Ceil(sx + xHalfWidth)) - if jx > sr.Max.X { - jx = sr.Max.X - } - - totalXWeight := 0.0 - for kx := ix; kx < jx; kx++ { - xWeight := 0.0 - if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { - xWeight = q.At(t) - } - xWeights[kx-ix] = xWeight - totalXWeight += xWeight - } - for x := range xWeights[:jx-ix] { - xWeights[x] /= totalXWeight - } - - sy += float64(bias.Y) - sy -= 0.5 - iy := int(math.Floor(sy - yHalfWidth)) - if iy < sr.Min.Y { - iy = sr.Min.Y - } - jy := int(math.Ceil(sy + yHalfWidth)) - if jy > sr.Max.Y { - jy = sr.Max.Y - } - - totalYWeight := 0.0 - for ky := iy; ky < jy; ky++ { - yWeight := 0.0 - if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { - yWeight = q.At(t) - } - yWeights[ky-iy] = yWeight - totalYWeight += yWeight - } - for y := range yWeights[:jy-iy] { - yWeights[y] /= totalYWeight - } - - var pr, pg, pb, pa float64 - for ky := iy; ky < jy; ky++ { - if yWeight := yWeights[ky-iy]; yWeight != 0 { - for kx := ix; kx < jx; kx++ { - if w := xWeights[kx-ix] * yWeight; w != 0 { - pi := (ky-src.Rect.Min.Y)*src.Stride + (kx-src.Rect.Min.X)*4 - pau := uint32(src.Pix[pi+3]) * 0x101 - pru := uint32(src.Pix[pi+0]) * pau / 0xff - pgu := uint32(src.Pix[pi+1]) * pau / 0xff - pbu := uint32(src.Pix[pi+2]) * pau / 0xff - pr += float64(pru) * w - pg += float64(pgu) * w - pb += float64(pbu) * w - pa += float64(pau) * w - } - } - } - } - - if pr > pa { - pr = pa - } - if pg > pa { - pg = pa - } - if pb > pa { - pb = pa - } - - dst.Pix[d+0] = uint8(fffftou(pr) >> 8) - dst.Pix[d+1] = uint8(fffftou(pg) >> 8) - dst.Pix[d+2] = uint8(fffftou(pb) >> 8) - dst.Pix[d+3] = uint8(fffftou(pa) >> 8) - } - } -} - -func (q *Kernel) transform_RGBA_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { - // When shrinking, broaden the effective kernel support so that we still - // visit every source pixel. - xHalfWidth, xKernelArgScale := q.Support, 1.0 - if xscale > 1 { - xHalfWidth *= xscale - xKernelArgScale = 1 / xscale - } - yHalfWidth, yKernelArgScale := q.Support, 1.0 - if yscale > 1 { - yHalfWidth *= yscale - yKernelArgScale = 1 / yscale - } - - xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) - yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - // TODO: adjust the bias so that we can use int(f) instead - // of math.Floor(f) and math.Ceil(f). - sx += float64(bias.X) - sx -= 0.5 - ix := int(math.Floor(sx - xHalfWidth)) - if ix < sr.Min.X { - ix = sr.Min.X - } - jx := int(math.Ceil(sx + xHalfWidth)) - if jx > sr.Max.X { - jx = sr.Max.X - } - - totalXWeight := 0.0 - for kx := ix; kx < jx; kx++ { - xWeight := 0.0 - if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { - xWeight = q.At(t) - } - xWeights[kx-ix] = xWeight - totalXWeight += xWeight - } - for x := range xWeights[:jx-ix] { - xWeights[x] /= totalXWeight - } - - sy += float64(bias.Y) - sy -= 0.5 - iy := int(math.Floor(sy - yHalfWidth)) - if iy < sr.Min.Y { - iy = sr.Min.Y - } - jy := int(math.Ceil(sy + yHalfWidth)) - if jy > sr.Max.Y { - jy = sr.Max.Y - } - - totalYWeight := 0.0 - for ky := iy; ky < jy; ky++ { - yWeight := 0.0 - if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { - yWeight = q.At(t) - } - yWeights[ky-iy] = yWeight - totalYWeight += yWeight - } - for y := range yWeights[:jy-iy] { - yWeights[y] /= totalYWeight - } - - var pr, pg, pb, pa float64 - for ky := iy; ky < jy; ky++ { - if yWeight := yWeights[ky-iy]; yWeight != 0 { - for kx := ix; kx < jx; kx++ { - if w := xWeights[kx-ix] * yWeight; w != 0 { - pi := (ky-src.Rect.Min.Y)*src.Stride + (kx-src.Rect.Min.X)*4 - pru := uint32(src.Pix[pi+0]) * 0x101 - pgu := uint32(src.Pix[pi+1]) * 0x101 - pbu := uint32(src.Pix[pi+2]) * 0x101 - pau := uint32(src.Pix[pi+3]) * 0x101 - pr += float64(pru) * w - pg += float64(pgu) * w - pb += float64(pbu) * w - pa += float64(pau) * w - } - } - } - } - - if pr > pa { - pr = pa - } - if pg > pa { - pg = pa - } - if pb > pa { - pb = pa - } - - pr0 := uint32(fffftou(pr)) - pg0 := uint32(fffftou(pg)) - pb0 := uint32(fffftou(pb)) - pa0 := uint32(fffftou(pa)) - pa1 := (0xffff - uint32(pa0)) * 0x101 - dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr0) >> 8) - dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg0) >> 8) - dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb0) >> 8) - dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa0) >> 8) - } - } -} - -func (q *Kernel) transform_RGBA_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { - // When shrinking, broaden the effective kernel support so that we still - // visit every source pixel. - xHalfWidth, xKernelArgScale := q.Support, 1.0 - if xscale > 1 { - xHalfWidth *= xscale - xKernelArgScale = 1 / xscale - } - yHalfWidth, yKernelArgScale := q.Support, 1.0 - if yscale > 1 { - yHalfWidth *= yscale - yKernelArgScale = 1 / yscale - } - - xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) - yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - // TODO: adjust the bias so that we can use int(f) instead - // of math.Floor(f) and math.Ceil(f). - sx += float64(bias.X) - sx -= 0.5 - ix := int(math.Floor(sx - xHalfWidth)) - if ix < sr.Min.X { - ix = sr.Min.X - } - jx := int(math.Ceil(sx + xHalfWidth)) - if jx > sr.Max.X { - jx = sr.Max.X - } - - totalXWeight := 0.0 - for kx := ix; kx < jx; kx++ { - xWeight := 0.0 - if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { - xWeight = q.At(t) - } - xWeights[kx-ix] = xWeight - totalXWeight += xWeight - } - for x := range xWeights[:jx-ix] { - xWeights[x] /= totalXWeight - } - - sy += float64(bias.Y) - sy -= 0.5 - iy := int(math.Floor(sy - yHalfWidth)) - if iy < sr.Min.Y { - iy = sr.Min.Y - } - jy := int(math.Ceil(sy + yHalfWidth)) - if jy > sr.Max.Y { - jy = sr.Max.Y - } - - totalYWeight := 0.0 - for ky := iy; ky < jy; ky++ { - yWeight := 0.0 - if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { - yWeight = q.At(t) - } - yWeights[ky-iy] = yWeight - totalYWeight += yWeight - } - for y := range yWeights[:jy-iy] { - yWeights[y] /= totalYWeight - } - - var pr, pg, pb, pa float64 - for ky := iy; ky < jy; ky++ { - if yWeight := yWeights[ky-iy]; yWeight != 0 { - for kx := ix; kx < jx; kx++ { - if w := xWeights[kx-ix] * yWeight; w != 0 { - pi := (ky-src.Rect.Min.Y)*src.Stride + (kx-src.Rect.Min.X)*4 - pru := uint32(src.Pix[pi+0]) * 0x101 - pgu := uint32(src.Pix[pi+1]) * 0x101 - pbu := uint32(src.Pix[pi+2]) * 0x101 - pau := uint32(src.Pix[pi+3]) * 0x101 - pr += float64(pru) * w - pg += float64(pgu) * w - pb += float64(pbu) * w - pa += float64(pau) * w - } - } - } - } - - if pr > pa { - pr = pa - } - if pg > pa { - pg = pa - } - if pb > pa { - pb = pa - } - - dst.Pix[d+0] = uint8(fffftou(pr) >> 8) - dst.Pix[d+1] = uint8(fffftou(pg) >> 8) - dst.Pix[d+2] = uint8(fffftou(pb) >> 8) - dst.Pix[d+3] = uint8(fffftou(pa) >> 8) - } - } -} - -func (q *Kernel) transform_RGBA_YCbCr444_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { - // When shrinking, broaden the effective kernel support so that we still - // visit every source pixel. - xHalfWidth, xKernelArgScale := q.Support, 1.0 - if xscale > 1 { - xHalfWidth *= xscale - xKernelArgScale = 1 / xscale - } - yHalfWidth, yKernelArgScale := q.Support, 1.0 - if yscale > 1 { - yHalfWidth *= yscale - yKernelArgScale = 1 / yscale - } - - xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) - yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - // TODO: adjust the bias so that we can use int(f) instead - // of math.Floor(f) and math.Ceil(f). - sx += float64(bias.X) - sx -= 0.5 - ix := int(math.Floor(sx - xHalfWidth)) - if ix < sr.Min.X { - ix = sr.Min.X - } - jx := int(math.Ceil(sx + xHalfWidth)) - if jx > sr.Max.X { - jx = sr.Max.X - } - - totalXWeight := 0.0 - for kx := ix; kx < jx; kx++ { - xWeight := 0.0 - if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { - xWeight = q.At(t) - } - xWeights[kx-ix] = xWeight - totalXWeight += xWeight - } - for x := range xWeights[:jx-ix] { - xWeights[x] /= totalXWeight - } - - sy += float64(bias.Y) - sy -= 0.5 - iy := int(math.Floor(sy - yHalfWidth)) - if iy < sr.Min.Y { - iy = sr.Min.Y - } - jy := int(math.Ceil(sy + yHalfWidth)) - if jy > sr.Max.Y { - jy = sr.Max.Y - } - - totalYWeight := 0.0 - for ky := iy; ky < jy; ky++ { - yWeight := 0.0 - if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { - yWeight = q.At(t) - } - yWeights[ky-iy] = yWeight - totalYWeight += yWeight - } - for y := range yWeights[:jy-iy] { - yWeights[y] /= totalYWeight - } - - var pr, pg, pb float64 - for ky := iy; ky < jy; ky++ { - if yWeight := yWeights[ky-iy]; yWeight != 0 { - for kx := ix; kx < jx; kx++ { - if w := xWeights[kx-ix] * yWeight; w != 0 { - pi := (ky-src.Rect.Min.Y)*src.YStride + (kx - src.Rect.Min.X) - pj := (ky-src.Rect.Min.Y)*src.CStride + (kx - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pru := (pyy1 + 91881*pcr1) >> 8 - pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pbu := (pyy1 + 116130*pcb1) >> 8 - if pru < 0 { - pru = 0 - } else if pru > 0xffff { - pru = 0xffff - } - if pgu < 0 { - pgu = 0 - } else if pgu > 0xffff { - pgu = 0xffff - } - if pbu < 0 { - pbu = 0 - } else if pbu > 0xffff { - pbu = 0xffff - } - - pr += float64(pru) * w - pg += float64(pgu) * w - pb += float64(pbu) * w - } - } - } - } - dst.Pix[d+0] = uint8(fffftou(pr) >> 8) - dst.Pix[d+1] = uint8(fffftou(pg) >> 8) - dst.Pix[d+2] = uint8(fffftou(pb) >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (q *Kernel) transform_RGBA_YCbCr422_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { - // When shrinking, broaden the effective kernel support so that we still - // visit every source pixel. - xHalfWidth, xKernelArgScale := q.Support, 1.0 - if xscale > 1 { - xHalfWidth *= xscale - xKernelArgScale = 1 / xscale - } - yHalfWidth, yKernelArgScale := q.Support, 1.0 - if yscale > 1 { - yHalfWidth *= yscale - yKernelArgScale = 1 / yscale - } - - xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) - yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - // TODO: adjust the bias so that we can use int(f) instead - // of math.Floor(f) and math.Ceil(f). - sx += float64(bias.X) - sx -= 0.5 - ix := int(math.Floor(sx - xHalfWidth)) - if ix < sr.Min.X { - ix = sr.Min.X - } - jx := int(math.Ceil(sx + xHalfWidth)) - if jx > sr.Max.X { - jx = sr.Max.X - } - - totalXWeight := 0.0 - for kx := ix; kx < jx; kx++ { - xWeight := 0.0 - if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { - xWeight = q.At(t) - } - xWeights[kx-ix] = xWeight - totalXWeight += xWeight - } - for x := range xWeights[:jx-ix] { - xWeights[x] /= totalXWeight - } - - sy += float64(bias.Y) - sy -= 0.5 - iy := int(math.Floor(sy - yHalfWidth)) - if iy < sr.Min.Y { - iy = sr.Min.Y - } - jy := int(math.Ceil(sy + yHalfWidth)) - if jy > sr.Max.Y { - jy = sr.Max.Y - } - - totalYWeight := 0.0 - for ky := iy; ky < jy; ky++ { - yWeight := 0.0 - if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { - yWeight = q.At(t) - } - yWeights[ky-iy] = yWeight - totalYWeight += yWeight - } - for y := range yWeights[:jy-iy] { - yWeights[y] /= totalYWeight - } - - var pr, pg, pb float64 - for ky := iy; ky < jy; ky++ { - if yWeight := yWeights[ky-iy]; yWeight != 0 { - for kx := ix; kx < jx; kx++ { - if w := xWeights[kx-ix] * yWeight; w != 0 { - pi := (ky-src.Rect.Min.Y)*src.YStride + (kx - src.Rect.Min.X) - pj := (ky-src.Rect.Min.Y)*src.CStride + ((kx)/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pru := (pyy1 + 91881*pcr1) >> 8 - pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pbu := (pyy1 + 116130*pcb1) >> 8 - if pru < 0 { - pru = 0 - } else if pru > 0xffff { - pru = 0xffff - } - if pgu < 0 { - pgu = 0 - } else if pgu > 0xffff { - pgu = 0xffff - } - if pbu < 0 { - pbu = 0 - } else if pbu > 0xffff { - pbu = 0xffff - } - - pr += float64(pru) * w - pg += float64(pgu) * w - pb += float64(pbu) * w - } - } - } - } - dst.Pix[d+0] = uint8(fffftou(pr) >> 8) - dst.Pix[d+1] = uint8(fffftou(pg) >> 8) - dst.Pix[d+2] = uint8(fffftou(pb) >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (q *Kernel) transform_RGBA_YCbCr420_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { - // When shrinking, broaden the effective kernel support so that we still - // visit every source pixel. - xHalfWidth, xKernelArgScale := q.Support, 1.0 - if xscale > 1 { - xHalfWidth *= xscale - xKernelArgScale = 1 / xscale - } - yHalfWidth, yKernelArgScale := q.Support, 1.0 - if yscale > 1 { - yHalfWidth *= yscale - yKernelArgScale = 1 / yscale - } - - xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) - yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - // TODO: adjust the bias so that we can use int(f) instead - // of math.Floor(f) and math.Ceil(f). - sx += float64(bias.X) - sx -= 0.5 - ix := int(math.Floor(sx - xHalfWidth)) - if ix < sr.Min.X { - ix = sr.Min.X - } - jx := int(math.Ceil(sx + xHalfWidth)) - if jx > sr.Max.X { - jx = sr.Max.X - } - - totalXWeight := 0.0 - for kx := ix; kx < jx; kx++ { - xWeight := 0.0 - if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { - xWeight = q.At(t) - } - xWeights[kx-ix] = xWeight - totalXWeight += xWeight - } - for x := range xWeights[:jx-ix] { - xWeights[x] /= totalXWeight - } - - sy += float64(bias.Y) - sy -= 0.5 - iy := int(math.Floor(sy - yHalfWidth)) - if iy < sr.Min.Y { - iy = sr.Min.Y - } - jy := int(math.Ceil(sy + yHalfWidth)) - if jy > sr.Max.Y { - jy = sr.Max.Y - } - - totalYWeight := 0.0 - for ky := iy; ky < jy; ky++ { - yWeight := 0.0 - if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { - yWeight = q.At(t) - } - yWeights[ky-iy] = yWeight - totalYWeight += yWeight - } - for y := range yWeights[:jy-iy] { - yWeights[y] /= totalYWeight - } - - var pr, pg, pb float64 - for ky := iy; ky < jy; ky++ { - if yWeight := yWeights[ky-iy]; yWeight != 0 { - for kx := ix; kx < jx; kx++ { - if w := xWeights[kx-ix] * yWeight; w != 0 { - pi := (ky-src.Rect.Min.Y)*src.YStride + (kx - src.Rect.Min.X) - pj := ((ky)/2-src.Rect.Min.Y/2)*src.CStride + ((kx)/2 - src.Rect.Min.X/2) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pru := (pyy1 + 91881*pcr1) >> 8 - pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pbu := (pyy1 + 116130*pcb1) >> 8 - if pru < 0 { - pru = 0 - } else if pru > 0xffff { - pru = 0xffff - } - if pgu < 0 { - pgu = 0 - } else if pgu > 0xffff { - pgu = 0xffff - } - if pbu < 0 { - pbu = 0 - } else if pbu > 0xffff { - pbu = 0xffff - } - - pr += float64(pru) * w - pg += float64(pgu) * w - pb += float64(pbu) * w - } - } - } - } - dst.Pix[d+0] = uint8(fffftou(pr) >> 8) - dst.Pix[d+1] = uint8(fffftou(pg) >> 8) - dst.Pix[d+2] = uint8(fffftou(pb) >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (q *Kernel) transform_RGBA_YCbCr440_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { - // When shrinking, broaden the effective kernel support so that we still - // visit every source pixel. - xHalfWidth, xKernelArgScale := q.Support, 1.0 - if xscale > 1 { - xHalfWidth *= xscale - xKernelArgScale = 1 / xscale - } - yHalfWidth, yKernelArgScale := q.Support, 1.0 - if yscale > 1 { - yHalfWidth *= yscale - yKernelArgScale = 1 / yscale - } - - xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) - yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - // TODO: adjust the bias so that we can use int(f) instead - // of math.Floor(f) and math.Ceil(f). - sx += float64(bias.X) - sx -= 0.5 - ix := int(math.Floor(sx - xHalfWidth)) - if ix < sr.Min.X { - ix = sr.Min.X - } - jx := int(math.Ceil(sx + xHalfWidth)) - if jx > sr.Max.X { - jx = sr.Max.X - } - - totalXWeight := 0.0 - for kx := ix; kx < jx; kx++ { - xWeight := 0.0 - if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { - xWeight = q.At(t) - } - xWeights[kx-ix] = xWeight - totalXWeight += xWeight - } - for x := range xWeights[:jx-ix] { - xWeights[x] /= totalXWeight - } - - sy += float64(bias.Y) - sy -= 0.5 - iy := int(math.Floor(sy - yHalfWidth)) - if iy < sr.Min.Y { - iy = sr.Min.Y - } - jy := int(math.Ceil(sy + yHalfWidth)) - if jy > sr.Max.Y { - jy = sr.Max.Y - } - - totalYWeight := 0.0 - for ky := iy; ky < jy; ky++ { - yWeight := 0.0 - if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { - yWeight = q.At(t) - } - yWeights[ky-iy] = yWeight - totalYWeight += yWeight - } - for y := range yWeights[:jy-iy] { - yWeights[y] /= totalYWeight - } - - var pr, pg, pb float64 - for ky := iy; ky < jy; ky++ { - if yWeight := yWeights[ky-iy]; yWeight != 0 { - for kx := ix; kx < jx; kx++ { - if w := xWeights[kx-ix] * yWeight; w != 0 { - pi := (ky-src.Rect.Min.Y)*src.YStride + (kx - src.Rect.Min.X) - pj := ((ky)/2-src.Rect.Min.Y/2)*src.CStride + (kx - src.Rect.Min.X) - - // This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method. - pyy1 := int(src.Y[pi]) * 0x10101 - pcb1 := int(src.Cb[pj]) - 128 - pcr1 := int(src.Cr[pj]) - 128 - pru := (pyy1 + 91881*pcr1) >> 8 - pgu := (pyy1 - 22554*pcb1 - 46802*pcr1) >> 8 - pbu := (pyy1 + 116130*pcb1) >> 8 - if pru < 0 { - pru = 0 - } else if pru > 0xffff { - pru = 0xffff - } - if pgu < 0 { - pgu = 0 - } else if pgu > 0xffff { - pgu = 0xffff - } - if pbu < 0 { - pbu = 0 - } else if pbu > 0xffff { - pbu = 0xffff - } - - pr += float64(pru) * w - pg += float64(pgu) * w - pb += float64(pbu) * w - } - } - } - } - dst.Pix[d+0] = uint8(fffftou(pr) >> 8) - dst.Pix[d+1] = uint8(fffftou(pg) >> 8) - dst.Pix[d+2] = uint8(fffftou(pb) >> 8) - dst.Pix[d+3] = 0xff - } - } -} - -func (q *Kernel) transform_RGBA_Image_Over(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { - // When shrinking, broaden the effective kernel support so that we still - // visit every source pixel. - xHalfWidth, xKernelArgScale := q.Support, 1.0 - if xscale > 1 { - xHalfWidth *= xscale - xKernelArgScale = 1 / xscale - } - yHalfWidth, yKernelArgScale := q.Support, 1.0 - if yscale > 1 { - yHalfWidth *= yscale - yKernelArgScale = 1 / yscale - } - - xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) - yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - // TODO: adjust the bias so that we can use int(f) instead - // of math.Floor(f) and math.Ceil(f). - sx += float64(bias.X) - sx -= 0.5 - ix := int(math.Floor(sx - xHalfWidth)) - if ix < sr.Min.X { - ix = sr.Min.X - } - jx := int(math.Ceil(sx + xHalfWidth)) - if jx > sr.Max.X { - jx = sr.Max.X - } - - totalXWeight := 0.0 - for kx := ix; kx < jx; kx++ { - xWeight := 0.0 - if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { - xWeight = q.At(t) - } - xWeights[kx-ix] = xWeight - totalXWeight += xWeight - } - for x := range xWeights[:jx-ix] { - xWeights[x] /= totalXWeight - } - - sy += float64(bias.Y) - sy -= 0.5 - iy := int(math.Floor(sy - yHalfWidth)) - if iy < sr.Min.Y { - iy = sr.Min.Y - } - jy := int(math.Ceil(sy + yHalfWidth)) - if jy > sr.Max.Y { - jy = sr.Max.Y - } - - totalYWeight := 0.0 - for ky := iy; ky < jy; ky++ { - yWeight := 0.0 - if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { - yWeight = q.At(t) - } - yWeights[ky-iy] = yWeight - totalYWeight += yWeight - } - for y := range yWeights[:jy-iy] { - yWeights[y] /= totalYWeight - } - - var pr, pg, pb, pa float64 - for ky := iy; ky < jy; ky++ { - if yWeight := yWeights[ky-iy]; yWeight != 0 { - for kx := ix; kx < jx; kx++ { - if w := xWeights[kx-ix] * yWeight; w != 0 { - pru, pgu, pbu, pau := src.At(kx, ky).RGBA() - pr += float64(pru) * w - pg += float64(pgu) * w - pb += float64(pbu) * w - pa += float64(pau) * w - } - } - } - } - - if pr > pa { - pr = pa - } - if pg > pa { - pg = pa - } - if pb > pa { - pb = pa - } - - pr0 := uint32(fffftou(pr)) - pg0 := uint32(fffftou(pg)) - pb0 := uint32(fffftou(pb)) - pa0 := uint32(fffftou(pa)) - pa1 := (0xffff - uint32(pa0)) * 0x101 - dst.Pix[d+0] = uint8((uint32(dst.Pix[d+0])*pa1/0xffff + pr0) >> 8) - dst.Pix[d+1] = uint8((uint32(dst.Pix[d+1])*pa1/0xffff + pg0) >> 8) - dst.Pix[d+2] = uint8((uint32(dst.Pix[d+2])*pa1/0xffff + pb0) >> 8) - dst.Pix[d+3] = uint8((uint32(dst.Pix[d+3])*pa1/0xffff + pa0) >> 8) - } - } -} - -func (q *Kernel) transform_RGBA_Image_Src(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { - // When shrinking, broaden the effective kernel support so that we still - // visit every source pixel. - xHalfWidth, xKernelArgScale := q.Support, 1.0 - if xscale > 1 { - xHalfWidth *= xscale - xKernelArgScale = 1 / xscale - } - yHalfWidth, yKernelArgScale := q.Support, 1.0 - if yscale > 1 { - yHalfWidth *= yscale - yKernelArgScale = 1 / yscale - } - - xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) - yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) - - for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ { - dyf := float64(dr.Min.Y+int(dy)) + 0.5 - d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4 - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - // TODO: adjust the bias so that we can use int(f) instead - // of math.Floor(f) and math.Ceil(f). - sx += float64(bias.X) - sx -= 0.5 - ix := int(math.Floor(sx - xHalfWidth)) - if ix < sr.Min.X { - ix = sr.Min.X - } - jx := int(math.Ceil(sx + xHalfWidth)) - if jx > sr.Max.X { - jx = sr.Max.X - } - - totalXWeight := 0.0 - for kx := ix; kx < jx; kx++ { - xWeight := 0.0 - if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { - xWeight = q.At(t) - } - xWeights[kx-ix] = xWeight - totalXWeight += xWeight - } - for x := range xWeights[:jx-ix] { - xWeights[x] /= totalXWeight - } - - sy += float64(bias.Y) - sy -= 0.5 - iy := int(math.Floor(sy - yHalfWidth)) - if iy < sr.Min.Y { - iy = sr.Min.Y - } - jy := int(math.Ceil(sy + yHalfWidth)) - if jy > sr.Max.Y { - jy = sr.Max.Y - } - - totalYWeight := 0.0 - for ky := iy; ky < jy; ky++ { - yWeight := 0.0 - if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { - yWeight = q.At(t) - } - yWeights[ky-iy] = yWeight - totalYWeight += yWeight - } - for y := range yWeights[:jy-iy] { - yWeights[y] /= totalYWeight - } - - var pr, pg, pb, pa float64 - for ky := iy; ky < jy; ky++ { - if yWeight := yWeights[ky-iy]; yWeight != 0 { - for kx := ix; kx < jx; kx++ { - if w := xWeights[kx-ix] * yWeight; w != 0 { - pru, pgu, pbu, pau := src.At(kx, ky).RGBA() - pr += float64(pru) * w - pg += float64(pgu) * w - pb += float64(pbu) * w - pa += float64(pau) * w - } - } - } - } - - if pr > pa { - pr = pa - } - if pg > pa { - pg = pa - } - if pb > pa { - pb = pa - } - - dst.Pix[d+0] = uint8(fffftou(pr) >> 8) - dst.Pix[d+1] = uint8(fffftou(pg) >> 8) - dst.Pix[d+2] = uint8(fffftou(pb) >> 8) - dst.Pix[d+3] = uint8(fffftou(pa) >> 8) - } - } -} - -func (q *Kernel) transform_Image_Image_Over(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { - // When shrinking, broaden the effective kernel support so that we still - // visit every source pixel. - xHalfWidth, xKernelArgScale := q.Support, 1.0 - if xscale > 1 { - xHalfWidth *= xscale - xKernelArgScale = 1 / xscale - } - yHalfWidth, yKernelArgScale := q.Support, 1.0 - if yscale > 1 { - yHalfWidth *= yscale - yKernelArgScale = 1 / yscale - } - - xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) - yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) - - srcMask, smp := opts.SrcMask, opts.SrcMaskP - dstMask, dmp := opts.DstMask, opts.DstMaskP - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - // TODO: adjust the bias so that we can use int(f) instead - // of math.Floor(f) and math.Ceil(f). - sx += float64(bias.X) - sx -= 0.5 - ix := int(math.Floor(sx - xHalfWidth)) - if ix < sr.Min.X { - ix = sr.Min.X - } - jx := int(math.Ceil(sx + xHalfWidth)) - if jx > sr.Max.X { - jx = sr.Max.X - } - - totalXWeight := 0.0 - for kx := ix; kx < jx; kx++ { - xWeight := 0.0 - if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { - xWeight = q.At(t) - } - xWeights[kx-ix] = xWeight - totalXWeight += xWeight - } - for x := range xWeights[:jx-ix] { - xWeights[x] /= totalXWeight - } - - sy += float64(bias.Y) - sy -= 0.5 - iy := int(math.Floor(sy - yHalfWidth)) - if iy < sr.Min.Y { - iy = sr.Min.Y - } - jy := int(math.Ceil(sy + yHalfWidth)) - if jy > sr.Max.Y { - jy = sr.Max.Y - } - - totalYWeight := 0.0 - for ky := iy; ky < jy; ky++ { - yWeight := 0.0 - if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { - yWeight = q.At(t) - } - yWeights[ky-iy] = yWeight - totalYWeight += yWeight - } - for y := range yWeights[:jy-iy] { - yWeights[y] /= totalYWeight - } - - var pr, pg, pb, pa float64 - for ky := iy; ky < jy; ky++ { - if yWeight := yWeights[ky-iy]; yWeight != 0 { - for kx := ix; kx < jx; kx++ { - if w := xWeights[kx-ix] * yWeight; w != 0 { - pru, pgu, pbu, pau := src.At(kx, ky).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+kx, smp.Y+ky).RGBA() - pru = pru * ma / 0xffff - pgu = pgu * ma / 0xffff - pbu = pbu * ma / 0xffff - pau = pau * ma / 0xffff - } - pr += float64(pru) * w - pg += float64(pgu) * w - pb += float64(pbu) * w - pa += float64(pau) * w - } - } - } - } - - if pr > pa { - pr = pa - } - if pg > pa { - pg = pa - } - if pb > pa { - pb = pa - } - - qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() - pr0 := uint32(fffftou(pr)) - pg0 := uint32(fffftou(pg)) - pb0 := uint32(fffftou(pb)) - pa0 := uint32(fffftou(pa)) - if dstMask != nil { - _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() - pr0 = pr0 * ma / 0xffff - pg0 = pg0 * ma / 0xffff - pb0 = pb0 * ma / 0xffff - pa0 = pa0 * ma / 0xffff - } - pa1 := 0xffff - pa0 - dstColorRGBA64.R = uint16(qr*pa1/0xffff + pr0) - dstColorRGBA64.G = uint16(qg*pa1/0xffff + pg0) - dstColorRGBA64.B = uint16(qb*pa1/0xffff + pb0) - dstColorRGBA64.A = uint16(qa*pa1/0xffff + pa0) - dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) - } - } -} - -func (q *Kernel) transform_Image_Image_Src(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, xscale, yscale float64, opts *Options) { - // When shrinking, broaden the effective kernel support so that we still - // visit every source pixel. - xHalfWidth, xKernelArgScale := q.Support, 1.0 - if xscale > 1 { - xHalfWidth *= xscale - xKernelArgScale = 1 / xscale - } - yHalfWidth, yKernelArgScale := q.Support, 1.0 - if yscale > 1 { - yHalfWidth *= yscale - yKernelArgScale = 1 / yscale - } - - xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth))) - yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth))) - - srcMask, smp := opts.SrcMask, opts.SrcMaskP - dstMask, dmp := opts.DstMask, opts.DstMaskP - 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 - sx := d2s[0]*dxf + d2s[1]*dyf + d2s[2] - sy := d2s[3]*dxf + d2s[4]*dyf + d2s[5] - if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) { - continue - } - - // TODO: adjust the bias so that we can use int(f) instead - // of math.Floor(f) and math.Ceil(f). - sx += float64(bias.X) - sx -= 0.5 - ix := int(math.Floor(sx - xHalfWidth)) - if ix < sr.Min.X { - ix = sr.Min.X - } - jx := int(math.Ceil(sx + xHalfWidth)) - if jx > sr.Max.X { - jx = sr.Max.X - } - - totalXWeight := 0.0 - for kx := ix; kx < jx; kx++ { - xWeight := 0.0 - if t := abs((sx - float64(kx)) * xKernelArgScale); t < q.Support { - xWeight = q.At(t) - } - xWeights[kx-ix] = xWeight - totalXWeight += xWeight - } - for x := range xWeights[:jx-ix] { - xWeights[x] /= totalXWeight - } - - sy += float64(bias.Y) - sy -= 0.5 - iy := int(math.Floor(sy - yHalfWidth)) - if iy < sr.Min.Y { - iy = sr.Min.Y - } - jy := int(math.Ceil(sy + yHalfWidth)) - if jy > sr.Max.Y { - jy = sr.Max.Y - } - - totalYWeight := 0.0 - for ky := iy; ky < jy; ky++ { - yWeight := 0.0 - if t := abs((sy - float64(ky)) * yKernelArgScale); t < q.Support { - yWeight = q.At(t) - } - yWeights[ky-iy] = yWeight - totalYWeight += yWeight - } - for y := range yWeights[:jy-iy] { - yWeights[y] /= totalYWeight - } - - var pr, pg, pb, pa float64 - for ky := iy; ky < jy; ky++ { - if yWeight := yWeights[ky-iy]; yWeight != 0 { - for kx := ix; kx < jx; kx++ { - if w := xWeights[kx-ix] * yWeight; w != 0 { - pru, pgu, pbu, pau := src.At(kx, ky).RGBA() - if srcMask != nil { - _, _, _, ma := srcMask.At(smp.X+kx, smp.Y+ky).RGBA() - pru = pru * ma / 0xffff - pgu = pgu * ma / 0xffff - pbu = pbu * ma / 0xffff - pau = pau * ma / 0xffff - } - pr += float64(pru) * w - pg += float64(pgu) * w - pb += float64(pbu) * w - pa += float64(pau) * w - } - } - } - } - - if pr > pa { - pr = pa - } - if pg > pa { - pg = pa - } - if pb > pa { - pb = pa - } - - if dstMask != nil { - qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA() - _, _, _, ma := dstMask.At(dmp.X+dr.Min.X+int(dx), dmp.Y+dr.Min.Y+int(dy)).RGBA() - pr := uint32(fffftou(pr)) * ma / 0xffff - pg := uint32(fffftou(pg)) * ma / 0xffff - pb := uint32(fffftou(pb)) * ma / 0xffff - pa := uint32(fffftou(pa)) * ma / 0xffff - pa1 := 0xffff - ma - 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) - } else { - dstColorRGBA64.R = fffftou(pr) - dstColorRGBA64.G = fffftou(pg) - dstColorRGBA64.B = fffftou(pb) - dstColorRGBA64.A = fffftou(pa) - dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor) - } - } - } -} diff --git a/vendor/golang.org/x/image/draw/scale.go b/vendor/golang.org/x/image/draw/scale.go deleted file mode 100644 index 98ab404..0000000 --- a/vendor/golang.org/x/image/draw/scale.go +++ /dev/null @@ -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() -} -- cgit v1.2.3