aw/golang-image
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
d2f07f8aaa
golang-image/draw/impl.go

6669 lines
205 KiB
Go
Raw Normal View History

draw: autogenerate impl.go. Adding fast paths for concrete dst and src image types will be follow-up changes. Change-Id: Ib23e3cc46d9c7a52ebd5eddfbad09177b0b421af Reviewed-on: https://go-review.googlesource.com/5417 Reviewed-by: Rob Pike <r@golang.org>
2015-02-20 08:28:54 +01:00
// generated by "go run gen.go". DO NOT EDIT.
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
package draw
import (
"image"
"image/color"
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
"math"
draw: add Transformer and Option types. Just stub implementations for now. Actual implementations will be follow-up changes. Change-Id: Id21d9042a2073c2dc0f78c9977c4940f000a41df Reviewed-on: https://go-review.googlesource.com/6805 Reviewed-by: Rob Pike <r@golang.org>
2015-03-05 05:46:57 +01:00
"golang.org/x/image/math/f64"
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
)
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
func (z nnInterpolator) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) {
draw: have Scale and Transform recognize straight copies. This is only for the NearestNeighbor and ApproxBiLinear Interpolators. A Kernel interpolator will add blur even when the dst and src rectangles are the same size. We do not bother recognizing Transforms that are Scales. The performance difference is minimal, as you still need to do a per-dst-pixel inverse mapping either way. benchmark old ns/op new ns/op delta BenchmarkSimpleScaleCopy-8 4866297 29586 -99.39% BenchmarkSimpleTransformCopy-8 4875991 29531 -99.39% BenchmarkSimpleTransformScale-8 1208147 1223206 +1.25% Change-Id: If649ad27a4e81bcbb24b18315745c02c9186a5b7 Reviewed-on: https://go-review.googlesource.com/13004 Reviewed-by: Rob Pike <r@golang.org>
2015-07-31 10:09:14 +02:00
// Try to simplify a Scale to a Copy.
if dr.Size() == sr.Size() {
Copy(dst, dr.Min, src, sr, op, opts)
return
}
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
var o Options
if opts != nil {
o = *opts
}
draw: add a fast path for an image.Rectangle DstMask. Change-Id: Id5227b9d217b56a342bc1ffc735dababa8a9e3e9 Reviewed-on: https://go-review.googlesource.com/9233 Reviewed-by: Rob Pike <r@golang.org>
2015-04-22 07:24:07 +02:00
// adr is the affected destination pixels.
adr := dst.Bounds().Intersect(dr)
adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP)
draw: make Scale an Interpolator method instead of a function. This means that only Kernel values have a NewScaler method, which re-uses computation when scaling multiple images of the same dst and src dimensions. The NearestNeighbor and ApproxBiLinear scalers don't get any pre-computation to re-use, so don't need a NewScaler method just to satisfy the previous Interpolator interface. As a small bonus, NN.Scale and ABL.Scale should no longer allocate on the fast paths. This change is consistent the upcoming Transformer method, so that the Interpolator interface will be type Interpolator interface { Scale(etc) Transform(etc) } instead of type Interpolator interface { NewScaler(etc) Scaler Transform(etc) } I don't have a good theory for why the "func (ablInterpolator) scale_RGBA_RGBA" benchmark is such a dramatic improvement, but at least it's in the right direction. I'm calling the other benchmark changes as noise. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3233406 3169060 -1.99% BenchmarkScaleLargeDownAB 12018178 12011348 -0.06% BenchmarkScaleLargeDownBL 1420827834 1409335695 -0.81% BenchmarkScaleLargeDownCR 2820669690 2795534035 -0.89% BenchmarkScaleDownNN 866628 869241 +0.30% BenchmarkScaleDownAB 3175963 3216041 +1.26% BenchmarkScaleDownBL 26639767 26677003 +0.14% BenchmarkScaleDownCR 51720996 51621628 -0.19% BenchmarkScaleUpNN 42758485 43258611 +1.17% BenchmarkScaleUpAB 156693813 156943367 +0.16% BenchmarkScaleUpBL 69511444 69621698 +0.16% BenchmarkScaleUpCR 124530191 124885601 +0.29% BenchmarkScaleSrcGray 8992205 9129321 +1.52% BenchmarkScaleSrcNRGBA 9807837 9894466 +0.88% BenchmarkScaleSrcRGBA 1333188 1104282 -17.17% BenchmarkScaleSrcUniform 1147788 1162488 +1.28% BenchmarkScaleSrcYCbCr 12164542 12305373 +1.16% Change-Id: I2aee6c392eb7437e843260775aed97ce145b4d47 Reviewed-on: https://go-review.googlesource.com/6556 Reviewed-by: Rob Pike <r@golang.org>
2015-03-03 06:54:53 +01:00
if adr.Empty() || sr.Empty() {
draw: clip scaling to the dst bounds. This is necessary for the upcoming RGBA dst fast path. The RGBA.Set slow path will clip automatically. Accessing RGBA.Pix directly will not. Benchmarks look like noise to me: benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 6212108 6131166 -1.30% BenchmarkScaleLargeDownAB 15586042 15656681 +0.45% BenchmarkScaleLargeDownBL 1518783517 1508124217 -0.70% BenchmarkScaleLargeDownCR 2998969089 2978114154 -0.70% BenchmarkScaleDownNN 1821187 1809314 -0.65% BenchmarkScaleDownAB 4286983 4248974 -0.89% BenchmarkScaleDownBL 29396818 30181926 +2.67% BenchmarkScaleDownCR 56441945 57952417 +2.68% BenchmarkScaleUpNN 90325384 89734496 -0.65% BenchmarkScaleUpAB 211613922 211625435 +0.01% BenchmarkScaleUpBL 119730880 120817135 +0.91% BenchmarkScaleUpCR 178592665 182305702 +2.08% BenchmarkScaleSrcNRGBA 13271034 13210760 -0.45% BenchmarkScaleSrcRGBA 13082234 12997551 -0.65% BenchmarkScaleSrcUniform 4003966 3934184 -1.74% BenchmarkScaleSrcYCbCr 15939182 15900123 -0.25% Change-Id: Ibf2843bb3c4eb695b58030e7314053c669533016 Reviewed-on: https://go-review.googlesource.com/6073 Reviewed-by: Rob Pike <r@golang.org>
2015-02-26 06:20:04 +01:00
return
}
draw: add a fast path for an image.Rectangle DstMask. Change-Id: Id5227b9d217b56a342bc1ffc735dababa8a9e3e9 Reviewed-on: https://go-review.googlesource.com/9233 Reviewed-by: Rob Pike <r@golang.org>
2015-04-22 07:24:07 +02:00
// Make adr relative to dr.Min.
adr = adr.Sub(dr.Min)
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
if op == Over && o.SrcMask == nil && opaque(src) {
op = Src
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
}
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
// 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.
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
//
// Similarly, the fast paths assume that the masks are nil.
if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
switch op {
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case Over:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_Image_Image_Over(dst, dr, adr, src, sr, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case Src:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_Image_Image_Src(dst, dr, adr, src, sr, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
}
draw: add Scale and Transform fast paths for Uniform src images. benchmark old ns/op new ns/op delta BenchmarkScaleSrcUniform 1744610 6305 -99.64% BenchmarkTformABSrcUniform 586201 520028 -11.29% BenchmarkTformCRSrcUniform 586952 519151 -11.55% Change-Id: Ide9148f9e91bb6ec607fa7e9d78b35772ca189fe Reviewed-on: https://go-review.googlesource.com/7881 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 12:13:15 +01:00
} else if _, ok := src.(*image.Uniform); ok {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
Draw(dst, dr, src, src.Bounds().Min, op)
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
} else {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
switch op {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case Over:
switch dst := dst.(type) {
case *image.RGBA:
switch src := src.(type) {
case *image.NRGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_NRGBA_Over(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case *image.RGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_RGBA_Over(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_Image_Over(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
default:
switch src := src.(type) {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_Image_Image_Over(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case Src:
switch dst := dst.(type) {
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
case *image.RGBA:
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
switch src := src.(type) {
case *image.Gray:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_Gray_Src(dst, dr, adr, src, sr, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case *image.NRGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_NRGBA_Src(dst, dr, adr, src, sr, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case *image.RGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_RGBA_Src(dst, dr, adr, src, sr, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case *image.YCbCr:
switch src.SubsampleRatio {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_Image_Src(dst, dr, adr, src, sr, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case image.YCbCrSubsampleRatio444:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_YCbCr444_Src(dst, dr, adr, src, sr, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case image.YCbCrSubsampleRatio422:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_YCbCr422_Src(dst, dr, adr, src, sr, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case image.YCbCrSubsampleRatio420:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_YCbCr420_Src(dst, dr, adr, src, sr, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case image.YCbCrSubsampleRatio440:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_YCbCr440_Src(dst, dr, adr, src, sr, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_Image_Src(dst, dr, adr, src, sr, &o)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
default:
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
switch src := src.(type) {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_Image_Image_Src(dst, dr, adr, src, sr, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
}
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
}
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
image/draw: have Transform take a f64.Aff3 instead of a *f64.Aff3. It's more args (in terms of bytes), but fewer allocations (Transformer is an interface). Either way, it's not really that big of a deal, but the value instead of the pointer seems conceptually more correct. Change-Id: Ibea76da17cbda0d9633110fd56044b4e2c690e81 Reviewed-on: https://go-review.googlesource.com/12669 Reviewed-by: Rob Pike <r@golang.org>
2015-07-27 07:58:18 +02:00
func (z nnInterpolator) Transform(dst Image, s2d f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options) {
draw: have Scale and Transform recognize straight copies. This is only for the NearestNeighbor and ApproxBiLinear Interpolators. A Kernel interpolator will add blur even when the dst and src rectangles are the same size. We do not bother recognizing Transforms that are Scales. The performance difference is minimal, as you still need to do a per-dst-pixel inverse mapping either way. benchmark old ns/op new ns/op delta BenchmarkSimpleScaleCopy-8 4866297 29586 -99.39% BenchmarkSimpleTransformCopy-8 4875991 29531 -99.39% BenchmarkSimpleTransformScale-8 1208147 1223206 +1.25% Change-Id: If649ad27a4e81bcbb24b18315745c02c9186a5b7 Reviewed-on: https://go-review.googlesource.com/13004 Reviewed-by: Rob Pike <r@golang.org>
2015-07-31 10:09:14 +02:00
// 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
}
}
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
var o Options
if opts != nil {
o = *opts
}
image/draw: have Transform take a f64.Aff3 instead of a *f64.Aff3. It's more args (in terms of bytes), but fewer allocations (Transformer is an interface). Either way, it's not really that big of a deal, but the value instead of the pointer seems conceptually more correct. Change-Id: Ibea76da17cbda0d9633110fd56044b4e2c690e81 Reviewed-on: https://go-review.googlesource.com/12669 Reviewed-by: Rob Pike <r@golang.org>
2015-07-27 07:58:18 +02:00
dr := transformRect(&s2d, &sr)
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
// adr is the affected destination pixels.
adr := dst.Bounds().Intersect(dr)
draw: add a fast path for an image.Rectangle DstMask. Change-Id: Id5227b9d217b56a342bc1ffc735dababa8a9e3e9 Reviewed-on: https://go-review.googlesource.com/9233 Reviewed-by: Rob Pike <r@golang.org>
2015-04-22 07:24:07 +02:00
adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP)
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
if adr.Empty() || sr.Empty() {
return
}
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
if op == Over && o.SrcMask == nil && opaque(src) {
op = Src
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
}
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
image/draw: have Transform take a f64.Aff3 instead of a *f64.Aff3. It's more args (in terms of bytes), but fewer allocations (Transformer is an interface). Either way, it's not really that big of a deal, but the value instead of the pointer seems conceptually more correct. Change-Id: Ibea76da17cbda0d9633110fd56044b4e2c690e81 Reviewed-on: https://go-review.googlesource.com/12669 Reviewed-by: Rob Pike <r@golang.org>
2015-07-27 07:58:18 +02:00
d2s := invert(&s2d)
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
// 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.
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
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)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
// 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.
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
//
// Similarly, the fast paths assume that the masks are nil.
if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
switch op {
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case Over:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case Src:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
}
draw: add Scale and Transform fast paths for Uniform src images. benchmark old ns/op new ns/op delta BenchmarkScaleSrcUniform 1744610 6305 -99.64% BenchmarkTformABSrcUniform 586201 520028 -11.29% BenchmarkTformCRSrcUniform 586952 519151 -11.55% Change-Id: Ide9148f9e91bb6ec607fa7e9d78b35772ca189fe Reviewed-on: https://go-review.googlesource.com/7881 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 12:13:15 +01:00
} else if u, ok := src.(*image.Uniform); ok {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, op)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
} else {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
switch op {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case Over:
switch dst := dst.(type) {
case *image.RGBA:
switch src := src.(type) {
case *image.NRGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_NRGBA_Over(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case *image.RGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_RGBA_Over(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
default:
switch src := src.(type) {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case Src:
switch dst := dst.(type) {
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
case *image.RGBA:
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
switch src := src.(type) {
case *image.Gray:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_Gray_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case *image.NRGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_NRGBA_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case *image.RGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_RGBA_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case *image.YCbCr:
switch src.SubsampleRatio {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case image.YCbCrSubsampleRatio444:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_YCbCr444_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case image.YCbCrSubsampleRatio422:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_YCbCr422_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case image.YCbCrSubsampleRatio420:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_YCbCr420_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
case image.YCbCrSubsampleRatio440:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_YCbCr440_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
default:
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
switch src := src.(type) {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
}
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
draw: actually use type-specific Transform code paths. I simply forgot to do this in the previous change. Change-Id: I0ea5d6bb0a09154cb995a665476ffceb155bd49e Reviewed-on: https://go-review.googlesource.com/7651 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 00:57:00 +01:00
}
}
draw: add Transformer and Option types. Just stub implementations for now. Actual implementations will be follow-up changes. Change-Id: Id21d9042a2073c2dc0f78c9977c4940f000a41df Reviewed-on: https://go-review.googlesource.com/6805 Reviewed-by: Rob Pike <r@golang.org>
2015-03-05 05:46:57 +01:00
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (nnInterpolator) scale_RGBA_Gray_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.Gray, sr image.Rectangle, opts *Options) {
draw: make Scale an Interpolator method instead of a function. This means that only Kernel values have a NewScaler method, which re-uses computation when scaling multiple images of the same dst and src dimensions. The NearestNeighbor and ApproxBiLinear scalers don't get any pre-computation to re-use, so don't need a NewScaler method just to satisfy the previous Interpolator interface. As a small bonus, NN.Scale and ABL.Scale should no longer allocate on the fast paths. This change is consistent the upcoming Transformer method, so that the Interpolator interface will be type Interpolator interface { Scale(etc) Transform(etc) } instead of type Interpolator interface { NewScaler(etc) Scaler Transform(etc) } I don't have a good theory for why the "func (ablInterpolator) scale_RGBA_RGBA" benchmark is such a dramatic improvement, but at least it's in the right direction. I'm calling the other benchmark changes as noise. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3233406 3169060 -1.99% BenchmarkScaleLargeDownAB 12018178 12011348 -0.06% BenchmarkScaleLargeDownBL 1420827834 1409335695 -0.81% BenchmarkScaleLargeDownCR 2820669690 2795534035 -0.89% BenchmarkScaleDownNN 866628 869241 +0.30% BenchmarkScaleDownAB 3175963 3216041 +1.26% BenchmarkScaleDownBL 26639767 26677003 +0.14% BenchmarkScaleDownCR 51720996 51621628 -0.19% BenchmarkScaleUpNN 42758485 43258611 +1.17% BenchmarkScaleUpAB 156693813 156943367 +0.16% BenchmarkScaleUpBL 69511444 69621698 +0.16% BenchmarkScaleUpCR 124530191 124885601 +0.29% BenchmarkScaleSrcGray 8992205 9129321 +1.52% BenchmarkScaleSrcNRGBA 9807837 9894466 +0.88% BenchmarkScaleSrcRGBA 1333188 1104282 -17.17% BenchmarkScaleSrcUniform 1147788 1162488 +1.28% BenchmarkScaleSrcYCbCr 12164542 12305373 +1.16% Change-Id: I2aee6c392eb7437e843260775aed97ce145b4d47 Reviewed-on: https://go-review.googlesource.com/6556 Reviewed-by: Rob Pike <r@golang.org>
2015-03-03 06:54:53 +01:00
dw2 := uint64(dr.Dx()) * 2
dh2 := uint64(dr.Dy()) * 2
sw := uint64(sr.Dx())
sh := uint64(sr.Dy())
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: make Scale an Interpolator method instead of a function. This means that only Kernel values have a NewScaler method, which re-uses computation when scaling multiple images of the same dst and src dimensions. The NearestNeighbor and ApproxBiLinear scalers don't get any pre-computation to re-use, so don't need a NewScaler method just to satisfy the previous Interpolator interface. As a small bonus, NN.Scale and ABL.Scale should no longer allocate on the fast paths. This change is consistent the upcoming Transformer method, so that the Interpolator interface will be type Interpolator interface { Scale(etc) Transform(etc) } instead of type Interpolator interface { NewScaler(etc) Scaler Transform(etc) } I don't have a good theory for why the "func (ablInterpolator) scale_RGBA_RGBA" benchmark is such a dramatic improvement, but at least it's in the right direction. I'm calling the other benchmark changes as noise. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3233406 3169060 -1.99% BenchmarkScaleLargeDownAB 12018178 12011348 -0.06% BenchmarkScaleLargeDownBL 1420827834 1409335695 -0.81% BenchmarkScaleLargeDownCR 2820669690 2795534035 -0.89% BenchmarkScaleDownNN 866628 869241 +0.30% BenchmarkScaleDownAB 3175963 3216041 +1.26% BenchmarkScaleDownBL 26639767 26677003 +0.14% BenchmarkScaleDownCR 51720996 51621628 -0.19% BenchmarkScaleUpNN 42758485 43258611 +1.17% BenchmarkScaleUpAB 156693813 156943367 +0.16% BenchmarkScaleUpBL 69511444 69621698 +0.16% BenchmarkScaleUpCR 124530191 124885601 +0.29% BenchmarkScaleSrcGray 8992205 9129321 +1.52% BenchmarkScaleSrcNRGBA 9807837 9894466 +0.88% BenchmarkScaleSrcRGBA 1333188 1104282 -17.17% BenchmarkScaleSrcUniform 1147788 1162488 +1.28% BenchmarkScaleSrcYCbCr 12164542 12305373 +1.16% Change-Id: I2aee6c392eb7437e843260775aed97ce145b4d47 Reviewed-on: https://go-review.googlesource.com/6556 Reviewed-by: Rob Pike <r@golang.org>
2015-03-03 06:54:53 +01:00
sy := (2*uint64(dy) + 1) * sh / dh2
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: make Scale an Interpolator method instead of a function. This means that only Kernel values have a NewScaler method, which re-uses computation when scaling multiple images of the same dst and src dimensions. The NearestNeighbor and ApproxBiLinear scalers don't get any pre-computation to re-use, so don't need a NewScaler method just to satisfy the previous Interpolator interface. As a small bonus, NN.Scale and ABL.Scale should no longer allocate on the fast paths. This change is consistent the upcoming Transformer method, so that the Interpolator interface will be type Interpolator interface { Scale(etc) Transform(etc) } instead of type Interpolator interface { NewScaler(etc) Scaler Transform(etc) } I don't have a good theory for why the "func (ablInterpolator) scale_RGBA_RGBA" benchmark is such a dramatic improvement, but at least it's in the right direction. I'm calling the other benchmark changes as noise. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3233406 3169060 -1.99% BenchmarkScaleLargeDownAB 12018178 12011348 -0.06% BenchmarkScaleLargeDownBL 1420827834 1409335695 -0.81% BenchmarkScaleLargeDownCR 2820669690 2795534035 -0.89% BenchmarkScaleDownNN 866628 869241 +0.30% BenchmarkScaleDownAB 3175963 3216041 +1.26% BenchmarkScaleDownBL 26639767 26677003 +0.14% BenchmarkScaleDownCR 51720996 51621628 -0.19% BenchmarkScaleUpNN 42758485 43258611 +1.17% BenchmarkScaleUpAB 156693813 156943367 +0.16% BenchmarkScaleUpBL 69511444 69621698 +0.16% BenchmarkScaleUpCR 124530191 124885601 +0.29% BenchmarkScaleSrcGray 8992205 9129321 +1.52% BenchmarkScaleSrcNRGBA 9807837 9894466 +0.88% BenchmarkScaleSrcRGBA 1333188 1104282 -17.17% BenchmarkScaleSrcUniform 1147788 1162488 +1.28% BenchmarkScaleSrcYCbCr 12164542 12305373 +1.16% Change-Id: I2aee6c392eb7437e843260775aed97ce145b4d47 Reviewed-on: https://go-review.googlesource.com/6556 Reviewed-by: Rob Pike <r@golang.org>
2015-03-03 06:54:53 +01:00
sx := (2*uint64(dx) + 1) * sw / dw2
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx) - src.Rect.Min.X)
draw: add a fast path for Gray src images. benchmark old ns/op new ns/op delta BenchmarkScaleSrcGray 9296680 552705 -94.05% BenchmarkTformABSrcGray 6323894 817986 -87.07% BenchmarkTformCRSrcGray 39229583 4193194 -89.31% Change-Id: Ie7d43dfe323d49b245b47c3206b5aad2b50cb7fb Reviewed-on: https://go-review.googlesource.com/7711 Reviewed-by: Rob Pike <r@golang.org>
2015-03-18 04:29:15 +01:00
pr := uint32(src.Pix[pi]) * 0x101
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
out := uint8(pr >> 8)
draw: add a fast path for Gray src images. benchmark old ns/op new ns/op delta BenchmarkScaleSrcGray 9296680 552705 -94.05% BenchmarkTformABSrcGray 6323894 817986 -87.07% BenchmarkTformCRSrcGray 39229583 4193194 -89.31% Change-Id: Ie7d43dfe323d49b245b47c3206b5aad2b50cb7fb Reviewed-on: https://go-review.googlesource.com/7711 Reviewed-by: Rob Pike <r@golang.org>
2015-03-18 04:29:15 +01:00
dst.Pix[d+0] = out
dst.Pix[d+1] = out
dst.Pix[d+2] = out
dst.Pix[d+3] = 0xff
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (nnInterpolator) scale_RGBA_NRGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (nnInterpolator) scale_RGBA_NRGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle, opts *Options) {
draw: make Scale an Interpolator method instead of a function. This means that only Kernel values have a NewScaler method, which re-uses computation when scaling multiple images of the same dst and src dimensions. The NearestNeighbor and ApproxBiLinear scalers don't get any pre-computation to re-use, so don't need a NewScaler method just to satisfy the previous Interpolator interface. As a small bonus, NN.Scale and ABL.Scale should no longer allocate on the fast paths. This change is consistent the upcoming Transformer method, so that the Interpolator interface will be type Interpolator interface { Scale(etc) Transform(etc) } instead of type Interpolator interface { NewScaler(etc) Scaler Transform(etc) } I don't have a good theory for why the "func (ablInterpolator) scale_RGBA_RGBA" benchmark is such a dramatic improvement, but at least it's in the right direction. I'm calling the other benchmark changes as noise. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3233406 3169060 -1.99% BenchmarkScaleLargeDownAB 12018178 12011348 -0.06% BenchmarkScaleLargeDownBL 1420827834 1409335695 -0.81% BenchmarkScaleLargeDownCR 2820669690 2795534035 -0.89% BenchmarkScaleDownNN 866628 869241 +0.30% BenchmarkScaleDownAB 3175963 3216041 +1.26% BenchmarkScaleDownBL 26639767 26677003 +0.14% BenchmarkScaleDownCR 51720996 51621628 -0.19% BenchmarkScaleUpNN 42758485 43258611 +1.17% BenchmarkScaleUpAB 156693813 156943367 +0.16% BenchmarkScaleUpBL 69511444 69621698 +0.16% BenchmarkScaleUpCR 124530191 124885601 +0.29% BenchmarkScaleSrcGray 8992205 9129321 +1.52% BenchmarkScaleSrcNRGBA 9807837 9894466 +0.88% BenchmarkScaleSrcRGBA 1333188 1104282 -17.17% BenchmarkScaleSrcUniform 1147788 1162488 +1.28% BenchmarkScaleSrcYCbCr 12164542 12305373 +1.16% Change-Id: I2aee6c392eb7437e843260775aed97ce145b4d47 Reviewed-on: https://go-review.googlesource.com/6556 Reviewed-by: Rob Pike <r@golang.org>
2015-03-03 06:54:53 +01:00
dw2 := uint64(dr.Dx()) * 2
dh2 := uint64(dr.Dy()) * 2
sw := uint64(sr.Dx())
sh := uint64(sr.Dy())
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: make Scale an Interpolator method instead of a function. This means that only Kernel values have a NewScaler method, which re-uses computation when scaling multiple images of the same dst and src dimensions. The NearestNeighbor and ApproxBiLinear scalers don't get any pre-computation to re-use, so don't need a NewScaler method just to satisfy the previous Interpolator interface. As a small bonus, NN.Scale and ABL.Scale should no longer allocate on the fast paths. This change is consistent the upcoming Transformer method, so that the Interpolator interface will be type Interpolator interface { Scale(etc) Transform(etc) } instead of type Interpolator interface { NewScaler(etc) Scaler Transform(etc) } I don't have a good theory for why the "func (ablInterpolator) scale_RGBA_RGBA" benchmark is such a dramatic improvement, but at least it's in the right direction. I'm calling the other benchmark changes as noise. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3233406 3169060 -1.99% BenchmarkScaleLargeDownAB 12018178 12011348 -0.06% BenchmarkScaleLargeDownBL 1420827834 1409335695 -0.81% BenchmarkScaleLargeDownCR 2820669690 2795534035 -0.89% BenchmarkScaleDownNN 866628 869241 +0.30% BenchmarkScaleDownAB 3175963 3216041 +1.26% BenchmarkScaleDownBL 26639767 26677003 +0.14% BenchmarkScaleDownCR 51720996 51621628 -0.19% BenchmarkScaleUpNN 42758485 43258611 +1.17% BenchmarkScaleUpAB 156693813 156943367 +0.16% BenchmarkScaleUpBL 69511444 69621698 +0.16% BenchmarkScaleUpCR 124530191 124885601 +0.29% BenchmarkScaleSrcGray 8992205 9129321 +1.52% BenchmarkScaleSrcNRGBA 9807837 9894466 +0.88% BenchmarkScaleSrcRGBA 1333188 1104282 -17.17% BenchmarkScaleSrcUniform 1147788 1162488 +1.28% BenchmarkScaleSrcYCbCr 12164542 12305373 +1.16% Change-Id: I2aee6c392eb7437e843260775aed97ce145b4d47 Reviewed-on: https://go-review.googlesource.com/6556 Reviewed-by: Rob Pike <r@golang.org>
2015-03-03 06:54:53 +01:00
sy := (2*uint64(dy) + 1) * sh / dh2
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: make Scale an Interpolator method instead of a function. This means that only Kernel values have a NewScaler method, which re-uses computation when scaling multiple images of the same dst and src dimensions. The NearestNeighbor and ApproxBiLinear scalers don't get any pre-computation to re-use, so don't need a NewScaler method just to satisfy the previous Interpolator interface. As a small bonus, NN.Scale and ABL.Scale should no longer allocate on the fast paths. This change is consistent the upcoming Transformer method, so that the Interpolator interface will be type Interpolator interface { Scale(etc) Transform(etc) } instead of type Interpolator interface { NewScaler(etc) Scaler Transform(etc) } I don't have a good theory for why the "func (ablInterpolator) scale_RGBA_RGBA" benchmark is such a dramatic improvement, but at least it's in the right direction. I'm calling the other benchmark changes as noise. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3233406 3169060 -1.99% BenchmarkScaleLargeDownAB 12018178 12011348 -0.06% BenchmarkScaleLargeDownBL 1420827834 1409335695 -0.81% BenchmarkScaleLargeDownCR 2820669690 2795534035 -0.89% BenchmarkScaleDownNN 866628 869241 +0.30% BenchmarkScaleDownAB 3175963 3216041 +1.26% BenchmarkScaleDownBL 26639767 26677003 +0.14% BenchmarkScaleDownCR 51720996 51621628 -0.19% BenchmarkScaleUpNN 42758485 43258611 +1.17% BenchmarkScaleUpAB 156693813 156943367 +0.16% BenchmarkScaleUpBL 69511444 69621698 +0.16% BenchmarkScaleUpCR 124530191 124885601 +0.29% BenchmarkScaleSrcGray 8992205 9129321 +1.52% BenchmarkScaleSrcNRGBA 9807837 9894466 +0.88% BenchmarkScaleSrcRGBA 1333188 1104282 -17.17% BenchmarkScaleSrcUniform 1147788 1162488 +1.28% BenchmarkScaleSrcYCbCr 12164542 12305373 +1.16% Change-Id: I2aee6c392eb7437e843260775aed97ce145b4d47 Reviewed-on: https://go-review.googlesource.com/6556 Reviewed-by: Rob Pike <r@golang.org>
2015-03-03 06:54:53 +01:00
sx := (2*uint64(dx) + 1) * sw / dw2
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx)-src.Rect.Min.X)*4
draw: add a fast path for NRGBA src images. benchmark old ns/op new ns/op delta BenchmarkScaleSrcNRGBA 14142583 2043782 -85.55% BenchmarkTformABSrcNRGBA 9846421 1993564 -79.75% BenchmarkTformCRSrcNRGBA 62041569 13866457 -77.65% Change-Id: I1edf699dfc6436c0da7e3ab221684406ab1e362f Reviewed-on: https://go-review.googlesource.com/7793 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 10:25:07 +01:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (nnInterpolator) scale_RGBA_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (nnInterpolator) scale_RGBA_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle, opts *Options) {
draw: make Scale an Interpolator method instead of a function. This means that only Kernel values have a NewScaler method, which re-uses computation when scaling multiple images of the same dst and src dimensions. The NearestNeighbor and ApproxBiLinear scalers don't get any pre-computation to re-use, so don't need a NewScaler method just to satisfy the previous Interpolator interface. As a small bonus, NN.Scale and ABL.Scale should no longer allocate on the fast paths. This change is consistent the upcoming Transformer method, so that the Interpolator interface will be type Interpolator interface { Scale(etc) Transform(etc) } instead of type Interpolator interface { NewScaler(etc) Scaler Transform(etc) } I don't have a good theory for why the "func (ablInterpolator) scale_RGBA_RGBA" benchmark is such a dramatic improvement, but at least it's in the right direction. I'm calling the other benchmark changes as noise. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3233406 3169060 -1.99% BenchmarkScaleLargeDownAB 12018178 12011348 -0.06% BenchmarkScaleLargeDownBL 1420827834 1409335695 -0.81% BenchmarkScaleLargeDownCR 2820669690 2795534035 -0.89% BenchmarkScaleDownNN 866628 869241 +0.30% BenchmarkScaleDownAB 3175963 3216041 +1.26% BenchmarkScaleDownBL 26639767 26677003 +0.14% BenchmarkScaleDownCR 51720996 51621628 -0.19% BenchmarkScaleUpNN 42758485 43258611 +1.17% BenchmarkScaleUpAB 156693813 156943367 +0.16% BenchmarkScaleUpBL 69511444 69621698 +0.16% BenchmarkScaleUpCR 124530191 124885601 +0.29% BenchmarkScaleSrcGray 8992205 9129321 +1.52% BenchmarkScaleSrcNRGBA 9807837 9894466 +0.88% BenchmarkScaleSrcRGBA 1333188 1104282 -17.17% BenchmarkScaleSrcUniform 1147788 1162488 +1.28% BenchmarkScaleSrcYCbCr 12164542 12305373 +1.16% Change-Id: I2aee6c392eb7437e843260775aed97ce145b4d47 Reviewed-on: https://go-review.googlesource.com/6556 Reviewed-by: Rob Pike <r@golang.org>
2015-03-03 06:54:53 +01:00
dw2 := uint64(dr.Dx()) * 2
dh2 := uint64(dr.Dy()) * 2
sw := uint64(sr.Dx())
sh := uint64(sr.Dy())
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: make Scale an Interpolator method instead of a function. This means that only Kernel values have a NewScaler method, which re-uses computation when scaling multiple images of the same dst and src dimensions. The NearestNeighbor and ApproxBiLinear scalers don't get any pre-computation to re-use, so don't need a NewScaler method just to satisfy the previous Interpolator interface. As a small bonus, NN.Scale and ABL.Scale should no longer allocate on the fast paths. This change is consistent the upcoming Transformer method, so that the Interpolator interface will be type Interpolator interface { Scale(etc) Transform(etc) } instead of type Interpolator interface { NewScaler(etc) Scaler Transform(etc) } I don't have a good theory for why the "func (ablInterpolator) scale_RGBA_RGBA" benchmark is such a dramatic improvement, but at least it's in the right direction. I'm calling the other benchmark changes as noise. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3233406 3169060 -1.99% BenchmarkScaleLargeDownAB 12018178 12011348 -0.06% BenchmarkScaleLargeDownBL 1420827834 1409335695 -0.81% BenchmarkScaleLargeDownCR 2820669690 2795534035 -0.89% BenchmarkScaleDownNN 866628 869241 +0.30% BenchmarkScaleDownAB 3175963 3216041 +1.26% BenchmarkScaleDownBL 26639767 26677003 +0.14% BenchmarkScaleDownCR 51720996 51621628 -0.19% BenchmarkScaleUpNN 42758485 43258611 +1.17% BenchmarkScaleUpAB 156693813 156943367 +0.16% BenchmarkScaleUpBL 69511444 69621698 +0.16% BenchmarkScaleUpCR 124530191 124885601 +0.29% BenchmarkScaleSrcGray 8992205 9129321 +1.52% BenchmarkScaleSrcNRGBA 9807837 9894466 +0.88% BenchmarkScaleSrcRGBA 1333188 1104282 -17.17% BenchmarkScaleSrcUniform 1147788 1162488 +1.28% BenchmarkScaleSrcYCbCr 12164542 12305373 +1.16% Change-Id: I2aee6c392eb7437e843260775aed97ce145b4d47 Reviewed-on: https://go-review.googlesource.com/6556 Reviewed-by: Rob Pike <r@golang.org>
2015-03-03 06:54:53 +01:00
sy := (2*uint64(dy) + 1) * sh / dh2
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: make Scale an Interpolator method instead of a function. This means that only Kernel values have a NewScaler method, which re-uses computation when scaling multiple images of the same dst and src dimensions. The NearestNeighbor and ApproxBiLinear scalers don't get any pre-computation to re-use, so don't need a NewScaler method just to satisfy the previous Interpolator interface. As a small bonus, NN.Scale and ABL.Scale should no longer allocate on the fast paths. This change is consistent the upcoming Transformer method, so that the Interpolator interface will be type Interpolator interface { Scale(etc) Transform(etc) } instead of type Interpolator interface { NewScaler(etc) Scaler Transform(etc) } I don't have a good theory for why the "func (ablInterpolator) scale_RGBA_RGBA" benchmark is such a dramatic improvement, but at least it's in the right direction. I'm calling the other benchmark changes as noise. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3233406 3169060 -1.99% BenchmarkScaleLargeDownAB 12018178 12011348 -0.06% BenchmarkScaleLargeDownBL 1420827834 1409335695 -0.81% BenchmarkScaleLargeDownCR 2820669690 2795534035 -0.89% BenchmarkScaleDownNN 866628 869241 +0.30% BenchmarkScaleDownAB 3175963 3216041 +1.26% BenchmarkScaleDownBL 26639767 26677003 +0.14% BenchmarkScaleDownCR 51720996 51621628 -0.19% BenchmarkScaleUpNN 42758485 43258611 +1.17% BenchmarkScaleUpAB 156693813 156943367 +0.16% BenchmarkScaleUpBL 69511444 69621698 +0.16% BenchmarkScaleUpCR 124530191 124885601 +0.29% BenchmarkScaleSrcGray 8992205 9129321 +1.52% BenchmarkScaleSrcNRGBA 9807837 9894466 +0.88% BenchmarkScaleSrcRGBA 1333188 1104282 -17.17% BenchmarkScaleSrcUniform 1147788 1162488 +1.28% BenchmarkScaleSrcYCbCr 12164542 12305373 +1.16% Change-Id: I2aee6c392eb7437e843260775aed97ce145b4d47 Reviewed-on: https://go-review.googlesource.com/6556 Reviewed-by: Rob Pike <r@golang.org>
2015-03-03 06:54:53 +01:00
sx := (2*uint64(dx) + 1) * sw / dw2
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
pi := (sr.Min.Y+int(sy)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx)-src.Rect.Min.X)*4
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (nnInterpolator) scale_RGBA_YCbCr444_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) {
draw: make Scale an Interpolator method instead of a function. This means that only Kernel values have a NewScaler method, which re-uses computation when scaling multiple images of the same dst and src dimensions. The NearestNeighbor and ApproxBiLinear scalers don't get any pre-computation to re-use, so don't need a NewScaler method just to satisfy the previous Interpolator interface. As a small bonus, NN.Scale and ABL.Scale should no longer allocate on the fast paths. This change is consistent the upcoming Transformer method, so that the Interpolator interface will be type Interpolator interface { Scale(etc) Transform(etc) } instead of type Interpolator interface { NewScaler(etc) Scaler Transform(etc) } I don't have a good theory for why the "func (ablInterpolator) scale_RGBA_RGBA" benchmark is such a dramatic improvement, but at least it's in the right direction. I'm calling the other benchmark changes as noise. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3233406 3169060 -1.99% BenchmarkScaleLargeDownAB 12018178 12011348 -0.06% BenchmarkScaleLargeDownBL 1420827834 1409335695 -0.81% BenchmarkScaleLargeDownCR 2820669690 2795534035 -0.89% BenchmarkScaleDownNN 866628 869241 +0.30% BenchmarkScaleDownAB 3175963 3216041 +1.26% BenchmarkScaleDownBL 26639767 26677003 +0.14% BenchmarkScaleDownCR 51720996 51621628 -0.19% BenchmarkScaleUpNN 42758485 43258611 +1.17% BenchmarkScaleUpAB 156693813 156943367 +0.16% BenchmarkScaleUpBL 69511444 69621698 +0.16% BenchmarkScaleUpCR 124530191 124885601 +0.29% BenchmarkScaleSrcGray 8992205 9129321 +1.52% BenchmarkScaleSrcNRGBA 9807837 9894466 +0.88% BenchmarkScaleSrcRGBA 1333188 1104282 -17.17% BenchmarkScaleSrcUniform 1147788 1162488 +1.28% BenchmarkScaleSrcYCbCr 12164542 12305373 +1.16% Change-Id: I2aee6c392eb7437e843260775aed97ce145b4d47 Reviewed-on: https://go-review.googlesource.com/6556 Reviewed-by: Rob Pike <r@golang.org>
2015-03-03 06:54:53 +01:00
dw2 := uint64(dr.Dx()) * 2
dh2 := uint64(dr.Dy()) * 2
sw := uint64(sr.Dx())
sh := uint64(sr.Dy())
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: make Scale an Interpolator method instead of a function. This means that only Kernel values have a NewScaler method, which re-uses computation when scaling multiple images of the same dst and src dimensions. The NearestNeighbor and ApproxBiLinear scalers don't get any pre-computation to re-use, so don't need a NewScaler method just to satisfy the previous Interpolator interface. As a small bonus, NN.Scale and ABL.Scale should no longer allocate on the fast paths. This change is consistent the upcoming Transformer method, so that the Interpolator interface will be type Interpolator interface { Scale(etc) Transform(etc) } instead of type Interpolator interface { NewScaler(etc) Scaler Transform(etc) } I don't have a good theory for why the "func (ablInterpolator) scale_RGBA_RGBA" benchmark is such a dramatic improvement, but at least it's in the right direction. I'm calling the other benchmark changes as noise. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3233406 3169060 -1.99% BenchmarkScaleLargeDownAB 12018178 12011348 -0.06% BenchmarkScaleLargeDownBL 1420827834 1409335695 -0.81% BenchmarkScaleLargeDownCR 2820669690 2795534035 -0.89% BenchmarkScaleDownNN 866628 869241 +0.30% BenchmarkScaleDownAB 3175963 3216041 +1.26% BenchmarkScaleDownBL 26639767 26677003 +0.14% BenchmarkScaleDownCR 51720996 51621628 -0.19% BenchmarkScaleUpNN 42758485 43258611 +1.17% BenchmarkScaleUpAB 156693813 156943367 +0.16% BenchmarkScaleUpBL 69511444 69621698 +0.16% BenchmarkScaleUpCR 124530191 124885601 +0.29% BenchmarkScaleSrcGray 8992205 9129321 +1.52% BenchmarkScaleSrcNRGBA 9807837 9894466 +0.88% BenchmarkScaleSrcRGBA 1333188 1104282 -17.17% BenchmarkScaleSrcUniform 1147788 1162488 +1.28% BenchmarkScaleSrcYCbCr 12164542 12305373 +1.16% Change-Id: I2aee6c392eb7437e843260775aed97ce145b4d47 Reviewed-on: https://go-review.googlesource.com/6556 Reviewed-by: Rob Pike <r@golang.org>
2015-03-03 06:54:53 +01:00
sy := (2*uint64(dy) + 1) * sh / dh2
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: make Scale an Interpolator method instead of a function. This means that only Kernel values have a NewScaler method, which re-uses computation when scaling multiple images of the same dst and src dimensions. The NearestNeighbor and ApproxBiLinear scalers don't get any pre-computation to re-use, so don't need a NewScaler method just to satisfy the previous Interpolator interface. As a small bonus, NN.Scale and ABL.Scale should no longer allocate on the fast paths. This change is consistent the upcoming Transformer method, so that the Interpolator interface will be type Interpolator interface { Scale(etc) Transform(etc) } instead of type Interpolator interface { NewScaler(etc) Scaler Transform(etc) } I don't have a good theory for why the "func (ablInterpolator) scale_RGBA_RGBA" benchmark is such a dramatic improvement, but at least it's in the right direction. I'm calling the other benchmark changes as noise. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3233406 3169060 -1.99% BenchmarkScaleLargeDownAB 12018178 12011348 -0.06% BenchmarkScaleLargeDownBL 1420827834 1409335695 -0.81% BenchmarkScaleLargeDownCR 2820669690 2795534035 -0.89% BenchmarkScaleDownNN 866628 869241 +0.30% BenchmarkScaleDownAB 3175963 3216041 +1.26% BenchmarkScaleDownBL 26639767 26677003 +0.14% BenchmarkScaleDownCR 51720996 51621628 -0.19% BenchmarkScaleUpNN 42758485 43258611 +1.17% BenchmarkScaleUpAB 156693813 156943367 +0.16% BenchmarkScaleUpBL 69511444 69621698 +0.16% BenchmarkScaleUpCR 124530191 124885601 +0.29% BenchmarkScaleSrcGray 8992205 9129321 +1.52% BenchmarkScaleSrcNRGBA 9807837 9894466 +0.88% BenchmarkScaleSrcRGBA 1333188 1104282 -17.17% BenchmarkScaleSrcUniform 1147788 1162488 +1.28% BenchmarkScaleSrcYCbCr 12164542 12305373 +1.16% Change-Id: I2aee6c392eb7437e843260775aed97ce145b4d47 Reviewed-on: https://go-review.googlesource.com/6556 Reviewed-by: Rob Pike <r@golang.org>
2015-03-03 06:54:53 +01:00
sx := (2*uint64(dx) + 1) * sw / dw2
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
pcb1 := int(src.Cb[pj]) - 128
pcr1 := int(src.Cr[pj]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
dst.Pix[d+0] = uint8(pr >> 8)
dst.Pix[d+1] = uint8(pg >> 8)
dst.Pix[d+2] = uint8(pb >> 8)
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
dst.Pix[d+3] = 0xff
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (nnInterpolator) scale_RGBA_YCbCr422_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dw2 := uint64(dr.Dx()) * 2
dh2 := uint64(dr.Dy()) * 2
sw := uint64(sr.Dx())
sh := uint64(sr.Dy())
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
sy := (2*uint64(dy) + 1) * sh / dh2
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
pcb1 := int(src.Cb[pj]) - 128
pcr1 := int(src.Cr[pj]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
dst.Pix[d+0] = uint8(pr >> 8)
dst.Pix[d+1] = uint8(pg >> 8)
dst.Pix[d+2] = uint8(pb >> 8)
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
dst.Pix[d+3] = 0xff
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (nnInterpolator) scale_RGBA_YCbCr420_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dw2 := uint64(dr.Dx()) * 2
dh2 := uint64(dr.Dy()) * 2
sw := uint64(sr.Dx())
sh := uint64(sr.Dy())
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
sy := (2*uint64(dy) + 1) * sh / dh2
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
pcb1 := int(src.Cb[pj]) - 128
pcr1 := int(src.Cr[pj]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
dst.Pix[d+0] = uint8(pr >> 8)
dst.Pix[d+1] = uint8(pg >> 8)
dst.Pix[d+2] = uint8(pb >> 8)
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
dst.Pix[d+3] = 0xff
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (nnInterpolator) scale_RGBA_YCbCr440_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dw2 := uint64(dr.Dx()) * 2
dh2 := uint64(dr.Dy()) * 2
sw := uint64(sr.Dx())
sh := uint64(sr.Dy())
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
sy := (2*uint64(dy) + 1) * sh / dh2
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
pcb1 := int(src.Cb[pj]) - 128
pcr1 := int(src.Cr[pj]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
dst.Pix[d+0] = uint8(pr >> 8)
dst.Pix[d+1] = uint8(pg >> 8)
dst.Pix[d+2] = uint8(pb >> 8)
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
dst.Pix[d+3] = 0xff
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (nnInterpolator) scale_RGBA_Image_Over(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dw2 := uint64(dr.Dx()) * 2
dh2 := uint64(dr.Dy()) * 2
sw := uint64(sr.Dx())
sh := uint64(sr.Dy())
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
sy := (2*uint64(dy) + 1) * sh / dh2
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
sx := (2*uint64(dx) + 1) * sw / dw2
pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA()
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (nnInterpolator) scale_RGBA_Image_Src(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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()
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (nnInterpolator) scale_Image_Image_Over(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dw2 := uint64(dr.Dx()) * 2
dh2 := uint64(dr.Dy()) * 2
sw := uint64(sr.Dx())
sh := uint64(sr.Dy())
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
srcMask, smp := opts.SrcMask, opts.SrcMaskP
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
dstMask, dmp := opts.DstMask, opts.DstMaskP
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
dstColorRGBA64 := &color.RGBA64{}
dstColor := color.Color(dstColorRGBA64)
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
sy := (2*uint64(dy) + 1) * sh / dh2
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
sx := (2*uint64(dx) + 1) * sw / dw2
pr, pg, pb, pa := src.At(sr.Min.X+int(sx), sr.Min.Y+int(sy)).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: implement the Over operator. Change-Id: Id207b8f2fa5233175285800477e60f111ef4af63 Reviewed-on: https://go-review.googlesource.com/8744 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 11:58:30 +02:00
qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA()
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
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
}
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor)
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (nnInterpolator) scale_Image_Image_Src(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dw2 := uint64(dr.Dx()) * 2
dh2 := uint64(dr.Dy()) * 2
sw := uint64(sr.Dx())
sh := uint64(sr.Dy())
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
srcMask, smp := opts.SrcMask, opts.SrcMaskP
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
dstMask, dmp := opts.DstMask, opts.DstMaskP
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
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)
}
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dyf := float64(dr.Min.Y+int(dy)) + 0.5
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
pi := (sy0-src.Rect.Min.Y)*src.Stride + (sx0 - src.Rect.Min.X)
pr := uint32(src.Pix[pi]) * 0x101
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
out := uint8(pr >> 8)
draw: add a fast path for Gray src images. benchmark old ns/op new ns/op delta BenchmarkScaleSrcGray 9296680 552705 -94.05% BenchmarkTformABSrcGray 6323894 817986 -87.07% BenchmarkTformCRSrcGray 39229583 4193194 -89.31% Change-Id: Ie7d43dfe323d49b245b47c3206b5aad2b50cb7fb Reviewed-on: https://go-review.googlesource.com/7711 Reviewed-by: Rob Pike <r@golang.org>
2015-03-18 04:29:15 +01:00
dst.Pix[d+0] = out
dst.Pix[d+1] = out
dst.Pix[d+2] = out
dst.Pix[d+3] = 0xff
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dyf := float64(dr.Min.Y+int(dy)) + 0.5
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dyf := float64(dr.Min.Y+int(dy)) + 0.5
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dyf := float64(dr.Min.Y+int(dy)) + 0.5
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if pg < 0 {
pg = 0
} else if pg > 0xffff {
pg = 0xffff
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if pb < 0 {
pb = 0
} else if pb > 0xffff {
pb = 0xffff
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
}
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
dst.Pix[d+0] = uint8(pr >> 8)
dst.Pix[d+1] = uint8(pg >> 8)
dst.Pix[d+2] = uint8(pb >> 8)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dst.Pix[d+3] = 0xff
}
}
}
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if pg < 0 {
pg = 0
} else if pg > 0xffff {
pg = 0xffff
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if pb < 0 {
pb = 0
} else if pb > 0xffff {
pb = 0xffff
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
}
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
dst.Pix[d+0] = uint8(pr >> 8)
dst.Pix[d+1] = uint8(pg >> 8)
dst.Pix[d+2] = uint8(pb >> 8)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dst.Pix[d+3] = 0xff
}
}
}
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if pg < 0 {
pg = 0
} else if pg > 0xffff {
pg = 0xffff
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if pb < 0 {
pb = 0
} else if pb > 0xffff {
pb = 0xffff
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
}
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
dst.Pix[d+0] = uint8(pr >> 8)
dst.Pix[d+1] = uint8(pg >> 8)
dst.Pix[d+2] = uint8(pb >> 8)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dst.Pix[d+3] = 0xff
}
}
}
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if pg < 0 {
pg = 0
} else if pg > 0xffff {
pg = 0xffff
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if pb < 0 {
pb = 0
} else if pb > 0xffff {
pb = 0xffff
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
}
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
dst.Pix[d+0] = uint8(pr >> 8)
dst.Pix[d+1] = uint8(pg >> 8)
dst.Pix[d+2] = uint8(pb >> 8)
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
dst.Pix[d+3] = 0xff
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: rename an internal function argument. This will lessen the diff in a follow-up change. Change-Id: I67257b935e4b5fc6fcc462c83910a3f09f26702f Reviewed-on: https://go-review.googlesource.com/6554 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-03-03 05:47:39 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dyf := float64(dr.Min.Y+int(dy)) + 0.5
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
pr, pg, pb, pa := src.At(sx0, sy0).RGBA()
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
}
}
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dyf := float64(dr.Min.Y+int(dy)) + 0.5
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
pr, pg, pb, pa := src.At(sx0, sy0).RGBA()
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
srcMask, smp := opts.SrcMask, opts.SrcMaskP
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
dstMask, dmp := opts.DstMask, opts.DstMaskP
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
dstColorRGBA64 := &color.RGBA64{}
dstColor := color.Color(dstColorRGBA64)
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: implement the Over operator. Change-Id: Id207b8f2fa5233175285800477e60f111ef4af63 Reviewed-on: https://go-review.googlesource.com/8744 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 11:58:30 +02:00
qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA()
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
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
}
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor)
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
srcMask, smp := opts.SrcMask, opts.SrcMaskP
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
dstMask, dmp := opts.DstMask, opts.DstMaskP
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
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)
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
func (z ablInterpolator) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) {
draw: have Scale and Transform recognize straight copies. This is only for the NearestNeighbor and ApproxBiLinear Interpolators. A Kernel interpolator will add blur even when the dst and src rectangles are the same size. We do not bother recognizing Transforms that are Scales. The performance difference is minimal, as you still need to do a per-dst-pixel inverse mapping either way. benchmark old ns/op new ns/op delta BenchmarkSimpleScaleCopy-8 4866297 29586 -99.39% BenchmarkSimpleTransformCopy-8 4875991 29531 -99.39% BenchmarkSimpleTransformScale-8 1208147 1223206 +1.25% Change-Id: If649ad27a4e81bcbb24b18315745c02c9186a5b7 Reviewed-on: https://go-review.googlesource.com/13004 Reviewed-by: Rob Pike <r@golang.org>
2015-07-31 10:09:14 +02:00
// Try to simplify a Scale to a Copy.
if dr.Size() == sr.Size() {
Copy(dst, dr.Min, src, sr, op, opts)
return
}
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
var o Options
if opts != nil {
o = *opts
}
draw: add a fast path for an image.Rectangle DstMask. Change-Id: Id5227b9d217b56a342bc1ffc735dababa8a9e3e9 Reviewed-on: https://go-review.googlesource.com/9233 Reviewed-by: Rob Pike <r@golang.org>
2015-04-22 07:24:07 +02:00
// adr is the affected destination pixels.
adr := dst.Bounds().Intersect(dr)
adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if adr.Empty() || sr.Empty() {
return
}
draw: add a fast path for an image.Rectangle DstMask. Change-Id: Id5227b9d217b56a342bc1ffc735dababa8a9e3e9 Reviewed-on: https://go-review.googlesource.com/9233 Reviewed-by: Rob Pike <r@golang.org>
2015-04-22 07:24:07 +02:00
// Make adr relative to dr.Min.
adr = adr.Sub(dr.Min)
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
if op == Over && o.SrcMask == nil && opaque(src) {
op = Src
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
}
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// 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.
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
//
// Similarly, the fast paths assume that the masks are nil.
if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
switch op {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case Over:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_Image_Image_Over(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case Src:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_Image_Image_Src(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
} else if _, ok := src.(*image.Uniform); ok {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
Draw(dst, dr, src, src.Bounds().Min, op)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
} else {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
switch op {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case Over:
switch dst := dst.(type) {
case *image.RGBA:
switch src := src.(type) {
case *image.NRGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_NRGBA_Over(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case *image.RGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_RGBA_Over(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_Image_Over(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
default:
switch src := src.(type) {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_Image_Image_Over(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
case Src:
switch dst := dst.(type) {
case *image.RGBA:
switch src := src.(type) {
case *image.Gray:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_Gray_Src(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case *image.NRGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_NRGBA_Src(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case *image.RGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_RGBA_Src(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case *image.YCbCr:
switch src.SubsampleRatio {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_Image_Src(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case image.YCbCrSubsampleRatio444:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_YCbCr444_Src(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case image.YCbCrSubsampleRatio422:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_YCbCr422_Src(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case image.YCbCrSubsampleRatio420:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_YCbCr420_Src(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case image.YCbCrSubsampleRatio440:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_YCbCr440_Src(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_RGBA_Image_Src(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
default:
switch src := src.(type) {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scale_Image_Image_Src(dst, dr, adr, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
}
}
image/draw: have Transform take a f64.Aff3 instead of a *f64.Aff3. It's more args (in terms of bytes), but fewer allocations (Transformer is an interface). Either way, it's not really that big of a deal, but the value instead of the pointer seems conceptually more correct. Change-Id: Ibea76da17cbda0d9633110fd56044b4e2c690e81 Reviewed-on: https://go-review.googlesource.com/12669 Reviewed-by: Rob Pike <r@golang.org>
2015-07-27 07:58:18 +02:00
func (z ablInterpolator) Transform(dst Image, s2d f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options) {
draw: have Scale and Transform recognize straight copies. This is only for the NearestNeighbor and ApproxBiLinear Interpolators. A Kernel interpolator will add blur even when the dst and src rectangles are the same size. We do not bother recognizing Transforms that are Scales. The performance difference is minimal, as you still need to do a per-dst-pixel inverse mapping either way. benchmark old ns/op new ns/op delta BenchmarkSimpleScaleCopy-8 4866297 29586 -99.39% BenchmarkSimpleTransformCopy-8 4875991 29531 -99.39% BenchmarkSimpleTransformScale-8 1208147 1223206 +1.25% Change-Id: If649ad27a4e81bcbb24b18315745c02c9186a5b7 Reviewed-on: https://go-review.googlesource.com/13004 Reviewed-by: Rob Pike <r@golang.org>
2015-07-31 10:09:14 +02:00
// 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
}
}
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
var o Options
if opts != nil {
o = *opts
}
image/draw: have Transform take a f64.Aff3 instead of a *f64.Aff3. It's more args (in terms of bytes), but fewer allocations (Transformer is an interface). Either way, it's not really that big of a deal, but the value instead of the pointer seems conceptually more correct. Change-Id: Ibea76da17cbda0d9633110fd56044b4e2c690e81 Reviewed-on: https://go-review.googlesource.com/12669 Reviewed-by: Rob Pike <r@golang.org>
2015-07-27 07:58:18 +02:00
dr := transformRect(&s2d, &sr)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// adr is the affected destination pixels.
adr := dst.Bounds().Intersect(dr)
draw: add a fast path for an image.Rectangle DstMask. Change-Id: Id5227b9d217b56a342bc1ffc735dababa8a9e3e9 Reviewed-on: https://go-review.googlesource.com/9233 Reviewed-by: Rob Pike <r@golang.org>
2015-04-22 07:24:07 +02:00
adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if adr.Empty() || sr.Empty() {
return
}
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
if op == Over && o.SrcMask == nil && opaque(src) {
op = Src
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
}
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
image/draw: have Transform take a f64.Aff3 instead of a *f64.Aff3. It's more args (in terms of bytes), but fewer allocations (Transformer is an interface). Either way, it's not really that big of a deal, but the value instead of the pointer seems conceptually more correct. Change-Id: Ibea76da17cbda0d9633110fd56044b4e2c690e81 Reviewed-on: https://go-review.googlesource.com/12669 Reviewed-by: Rob Pike <r@golang.org>
2015-07-27 07:58:18 +02:00
d2s := invert(&s2d)
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
// 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.
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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.
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
//
// Similarly, the fast paths assume that the masks are nil.
if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
switch op {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case Over:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case Src:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
} else if u, ok := src.(*image.Uniform); ok {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, op)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
} else {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
switch op {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case Over:
switch dst := dst.(type) {
case *image.RGBA:
switch src := src.(type) {
case *image.NRGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_NRGBA_Over(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case *image.RGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_RGBA_Over(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
default:
switch src := src.(type) {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
case Src:
switch dst := dst.(type) {
case *image.RGBA:
switch src := src.(type) {
case *image.Gray:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_Gray_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case *image.NRGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_NRGBA_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case *image.RGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_RGBA_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case *image.YCbCr:
switch src.SubsampleRatio {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case image.YCbCrSubsampleRatio444:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_YCbCr444_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case image.YCbCrSubsampleRatio422:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_YCbCr422_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case image.YCbCrSubsampleRatio420:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_YCbCr420_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
case image.YCbCrSubsampleRatio440:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_YCbCr440_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
default:
switch src := src.(type) {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (ablInterpolator) scale_RGBA_Gray_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.Gray, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
xFrac0 := sx - float64(sx0)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if sx < 0 {
sx0, sx1 = 0, 0
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
xFrac0, xFrac1 = 0, 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx0) - src.Rect.Min.X)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s00ru := uint32(src.Pix[s00i]) * 0x101
s00r := float64(s00ru)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx1) - src.Rect.Min.X)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s10ru := uint32(src.Pix[s10i]) * 0x101
s10r := float64(s10ru)
s10r = xFrac1*s00r + xFrac0*s10r
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx0) - src.Rect.Min.X)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s01ru := uint32(src.Pix[s01i]) * 0x101
s01r := float64(s01ru)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X + int(sx1) - src.Rect.Min.X)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s11ru := uint32(src.Pix[s11i]) * 0x101
s11r := float64(s11ru)
s11r = xFrac1*s01r + xFrac0*s11r
s11r = yFrac1*s10r + yFrac0*s11r
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
pr := uint32(s11r)
out := uint8(pr >> 8)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
dst.Pix[d+0] = out
dst.Pix[d+1] = out
dst.Pix[d+2] = out
dst.Pix[d+3] = 0xff
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (ablInterpolator) scale_RGBA_NRGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
xFrac0 := sx - float64(sx0)
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if sx < 0 {
sx0, sx1 = 0, 0
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac0, xFrac1 = 0, 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4
draw: add a fast path for NRGBA src images. benchmark old ns/op new ns/op delta BenchmarkScaleSrcNRGBA 14142583 2043782 -85.55% BenchmarkTformABSrcNRGBA 9846421 1993564 -79.75% BenchmarkTformCRSrcNRGBA 62041569 13866457 -77.65% Change-Id: I1edf699dfc6436c0da7e3ab221684406ab1e362f Reviewed-on: https://go-review.googlesource.com/7793 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 10:25:07 +01:00
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
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4
draw: add a fast path for NRGBA src images. benchmark old ns/op new ns/op delta BenchmarkScaleSrcNRGBA 14142583 2043782 -85.55% BenchmarkTformABSrcNRGBA 9846421 1993564 -79.75% BenchmarkTformCRSrcNRGBA 62041569 13866457 -77.65% Change-Id: I1edf699dfc6436c0da7e3ab221684406ab1e362f Reviewed-on: https://go-review.googlesource.com/7793 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 10:25:07 +01:00
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
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4
draw: add a fast path for NRGBA src images. benchmark old ns/op new ns/op delta BenchmarkScaleSrcNRGBA 14142583 2043782 -85.55% BenchmarkTformABSrcNRGBA 9846421 1993564 -79.75% BenchmarkTformCRSrcNRGBA 62041569 13866457 -77.65% Change-Id: I1edf699dfc6436c0da7e3ab221684406ab1e362f Reviewed-on: https://go-review.googlesource.com/7793 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 10:25:07 +01:00
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
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4
draw: add a fast path for NRGBA src images. benchmark old ns/op new ns/op delta BenchmarkScaleSrcNRGBA 14142583 2043782 -85.55% BenchmarkTformABSrcNRGBA 9846421 1993564 -79.75% BenchmarkTformCRSrcNRGBA 62041569 13866457 -77.65% Change-Id: I1edf699dfc6436c0da7e3ab221684406ab1e362f Reviewed-on: https://go-review.googlesource.com/7793 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 10:25:07 +01:00
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
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (ablInterpolator) scale_RGBA_NRGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
xFrac0 := sx - float64(sx0)
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if sx < 0 {
sx0, sx1 = 0, 0
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac0, xFrac1 = 0, 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s00au := uint32(src.Pix[s00i+3]) * 0x101
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00ru := uint32(src.Pix[s00i+0]) * s00au / 0xff
s00gu := uint32(src.Pix[s00i+1]) * s00au / 0xff
s00bu := uint32(src.Pix[s00i+2]) * s00au / 0xff
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10i := (sr.Min.Y+int(sy0)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s10au := uint32(src.Pix[s10i+3]) * 0x101
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10ru := uint32(src.Pix[s10i+0]) * s10au / 0xff
s10gu := uint32(src.Pix[s10i+1]) * s10au / 0xff
s10bu := uint32(src.Pix[s10i+2]) * s10au / 0xff
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx0)-src.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s01au := uint32(src.Pix[s01i+3]) * 0x101
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01ru := uint32(src.Pix[s01i+0]) * s01au / 0xff
s01gu := uint32(src.Pix[s01i+1]) * s01au / 0xff
s01bu := uint32(src.Pix[s01i+2]) * s01au / 0xff
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11i := (sr.Min.Y+int(sy1)-src.Rect.Min.Y)*src.Stride + (sr.Min.X+int(sx1)-src.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s11au := uint32(src.Pix[s11i+3]) * 0x101
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11ru := uint32(src.Pix[s11i+0]) * s11au / 0xff
s11gu := uint32(src.Pix[s11i+1]) * s11au / 0xff
s11bu := uint32(src.Pix[s11i+2]) * s11au / 0xff
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (ablInterpolator) scale_RGBA_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (ablInterpolator) scale_RGBA_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
xFrac0 := sx - float64(sx0)
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if sx < 0 {
sx0, sx1 = 0, 0
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac0, xFrac1 = 0, 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (ablInterpolator) scale_RGBA_YCbCr444_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s00yy1 := int(src.Y[s00i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s00cb1 := int(src.Cb[s00j]) - 128
s00cr1 := int(src.Cr[s00j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s10yy1 := int(src.Y[s10i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s10cb1 := int(src.Cb[s10j]) - 128
s10cr1 := int(src.Cr[s10j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s01yy1 := int(src.Y[s01i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s01cb1 := int(src.Cb[s01j]) - 128
s01cr1 := int(src.Cr[s01j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s11yy1 := int(src.Y[s11i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s11cb1 := int(src.Cb[s11j]) - 128
s11cr1 := int(src.Cr[s11j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
dst.Pix[d+3] = 0xff
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (ablInterpolator) scale_RGBA_YCbCr422_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
xFrac0 := sx - float64(sx0)
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if sx < 0 {
sx0, sx1 = 0, 0
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac0, xFrac1 = 0, 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s00yy1 := int(src.Y[s00i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s00cb1 := int(src.Cb[s00j]) - 128
s00cr1 := int(src.Cr[s00j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s10yy1 := int(src.Y[s10i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s10cb1 := int(src.Cb[s10j]) - 128
s10cr1 := int(src.Cr[s10j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s01yy1 := int(src.Y[s01i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s01cb1 := int(src.Cb[s01j]) - 128
s01cr1 := int(src.Cr[s01j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s11yy1 := int(src.Y[s11i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s11cb1 := int(src.Cb[s11j]) - 128
s11cr1 := int(src.Cr[s11j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
dst.Pix[d+3] = 0xff
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (ablInterpolator) scale_RGBA_YCbCr420_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
xFrac0 := sx - float64(sx0)
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if sx < 0 {
sx0, sx1 = 0, 0
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac0, xFrac1 = 0, 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s00yy1 := int(src.Y[s00i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s00cb1 := int(src.Cb[s00j]) - 128
s00cr1 := int(src.Cr[s00j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s10yy1 := int(src.Y[s10i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s10cb1 := int(src.Cb[s10j]) - 128
s10cr1 := int(src.Cr[s10j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s01yy1 := int(src.Y[s01i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s01cb1 := int(src.Cb[s01j]) - 128
s01cr1 := int(src.Cr[s01j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s11yy1 := int(src.Y[s11i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s11cb1 := int(src.Cb[s11j]) - 128
s11cr1 := int(src.Cr[s11j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
dst.Pix[d+3] = 0xff
draw: implement NearestNeighbor and ApproxBiLinear Transform. Change-Id: I70a5e3703dea436354e9591fce7b704ec749c2d1 Reviewed-on: https://go-review.googlesource.com/7541 Reviewed-by: Rob Pike <r@golang.org>
2015-03-13 07:44:34 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (ablInterpolator) scale_RGBA_YCbCr440_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
xFrac0 := sx - float64(sx0)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if sx < 0 {
sx0, sx1 = 0, 0
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
xFrac0, xFrac1 = 0, 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s00yy1 := int(src.Y[s00i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s00cb1 := int(src.Cb[s00j]) - 128
s00cr1 := int(src.Cr[s00j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s10yy1 := int(src.Y[s10i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s10cb1 := int(src.Cb[s10j]) - 128
s10cr1 := int(src.Cr[s10j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s01yy1 := int(src.Y[s01i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s01cb1 := int(src.Cb[s01j]) - 128
s01cr1 := int(src.Cr[s01j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s11yy1 := int(src.Y[s11i]) * 0x10100
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
s11cb1 := int(src.Cb[s11j]) - 128
s11cr1 := int(src.Cr[s11j]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
dst.Pix[d+3] = 0xff
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (ablInterpolator) scale_RGBA_Image_Over(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
xFrac0 := sx - float64(sx0)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if sx < 0 {
sx0, sx1 = 0, 0
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
xFrac0, xFrac1 = 0, 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA()
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00a := float64(s00au)
s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA()
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a := float64(s10au)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a = xFrac1*s00a + xFrac0*s10a
s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA()
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s01a := float64(s01au)
s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA()
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a := float64(s11au)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = xFrac1*s01a + xFrac0*s11a
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = yFrac1*s10a + yFrac0*s11a
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (ablInterpolator) scale_RGBA_Image_Src(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
xFrac0 := sx - float64(sx0)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
xFrac1 := 1 - xFrac0
sx1 := sx0 + 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
if sx < 0 {
sx0, sx1 = 0, 0
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
xFrac0, xFrac1 = 0, 1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
} else if sx1 > swMinus1 {
sx0, sx1 = swMinus1, swMinus1
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
xFrac0, xFrac1 = 1, 0
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA()
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00a := float64(s00au)
s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA()
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a := float64(s10au)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a = xFrac1*s00a + xFrac0*s10a
s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA()
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s01a := float64(s01au)
s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA()
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a := float64(s11au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s11b = xFrac1*s01b + xFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = xFrac1*s01a + xFrac0*s11a
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = yFrac1*s10a + yFrac0*s11a
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (ablInterpolator) scale_Image_Image_Over(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
srcMask, smp := opts.SrcMask, opts.SrcMaskP
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
dstMask, dmp := opts.DstMask, opts.DstMaskP
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
dstColorRGBA64 := &color.RGBA64{}
dstColor := color.Color(dstColorRGBA64)
draw: add Scale and Transform fast paths for Uniform src images. benchmark old ns/op new ns/op delta BenchmarkScaleSrcUniform 1744610 6305 -99.64% BenchmarkTformABSrcUniform 586201 520028 -11.29% BenchmarkTformCRSrcUniform 586952 519151 -11.55% Change-Id: Ide9148f9e91bb6ec607fa7e9d78b35772ca189fe Reviewed-on: https://go-review.googlesource.com/7881 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 12:13:15 +01:00
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: RGBA src fast path for scaling. benchmark old ns/op new ns/op delta BenchmarkScaleSrcRGBA 15124800 2091946 -86.17% Change-Id: Id8d3088793ebf1d75b929fcf6945987817e87463 Reviewed-on: https://go-review.googlesource.com/6234 Reviewed-by: Rob Pike <r@golang.org>
2015-02-27 11:26:47 +01:00
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00a := float64(s00au)
s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a := float64(s10au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a = xFrac1*s00a + xFrac0*s10a
s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s01a := float64(s01au)
s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a := float64(s11au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = xFrac1*s01a + xFrac0*s11a
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = yFrac1*s10a + yFrac0*s11a
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
pr := uint32(s11r)
pg := uint32(s11g)
pb := uint32(s11b)
pa := uint32(s11a)
draw: implement the Over operator. Change-Id: Id207b8f2fa5233175285800477e60f111ef4af63 Reviewed-on: https://go-review.googlesource.com/8744 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 11:58:30 +02:00
qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA()
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
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
}
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (ablInterpolator) scale_Image_Image_Src(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle, opts *Options) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
srcMask, smp := opts.SrcMask, opts.SrcMaskP
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
dstMask, dmp := opts.DstMask, opts.DstMaskP
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
dstColorRGBA64 := &color.RGBA64{}
dstColor := color.Color(dstColorRGBA64)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00ru, s00gu, s00bu, s00au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy0)).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00a := float64(s00au)
s10ru, s10gu, s10bu, s10au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy0)).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a := float64(s10au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a = xFrac1*s00a + xFrac0*s10a
s01ru, s01gu, s01bu, s01au := src.At(sr.Min.X+int(sx0), sr.Min.Y+int(sy1)).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s01a := float64(s01au)
s11ru, s11gu, s11bu, s11au := src.At(sr.Min.X+int(sx1), sr.Min.Y+int(sy1)).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a := float64(s11au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = xFrac1*s01a + xFrac0*s11a
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = yFrac1*s10a + yFrac0*s11a
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
pr := uint32(s11r)
pg := uint32(s11g)
pb := uint32(s11b)
pa := uint32(s11a)
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
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)
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
dyf := float64(dr.Min.Y+int(dy)) + 0.5
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
pr := uint32(s11r)
out := uint8(pr >> 8)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
dst.Pix[d+0] = out
dst.Pix[d+1] = out
dst.Pix[d+2] = out
dst.Pix[d+3] = 0xff
}
}
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx, d = dx+1, d+4 {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
xFrac0 := sx - float64(sx0)
xFrac1 := 1 - xFrac0
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
sx0 += bias.X
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
sx1 := sx0 + 1
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
if sx0 < sr.Min.X {
sx0, sx1 = sr.Min.X, sr.Min.X
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
xFrac0, xFrac1 = 0, 1
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
} else if sx1 >= sr.Max.X {
sx0, sx1 = sr.Max.X-1, sr.Max.X-1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
xFrac0, xFrac1 = 1, 0
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
dyf := float64(dr.Min.Y+int(dy)) + 0.5
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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 {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
xFrac0 := sx - float64(sx0)
xFrac1 := 1 - xFrac0
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
sx0 += bias.X
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
sx1 := sx0 + 1
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
if sx0 < sr.Min.X {
sx0, sx1 = sr.Min.X, sr.Min.X
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
xFrac0, xFrac1 = 0, 1
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
} else if sx1 >= sr.Max.X {
sx0, sx1 = sr.Max.X-1, sr.Max.X-1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
xFrac0, xFrac1 = 1, 0
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
sx -= 0.5
sx0 := int(sx)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
xFrac0 := sx - float64(sx0)
xFrac1 := 1 - xFrac0
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
sx0 += bias.X
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
sx1 := sx0 + 1
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
if sx0 < sr.Min.X {
sx0, sx1 = sr.Min.X, sr.Min.X
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
xFrac0, xFrac1 = 0, 1
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
} else if sx1 >= sr.Max.X {
sx0, sx1 = sr.Max.X-1, sr.Max.X-1
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
xFrac0, xFrac1 = 1, 0
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
s00a := float64(s00au)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
s01a := float64(s01au)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00r := float64(s00ru)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r := float64(s10ru)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10g := float64(s10gu)
s10b := float64(s10bu)
s10a := float64(s10au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r = xFrac1*s00r + xFrac0*s10r
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01r := float64(s01ru)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r := float64(s11ru)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11g := float64(s11gu)
s11b := float64(s11bu)
s11a := float64(s11au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = xFrac1*s01r + xFrac0*s11r
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
s11a = xFrac1*s01a + xFrac0*s11a
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = yFrac1*s10r + yFrac0*s11r
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
s11a = yFrac1*s10a + yFrac0*s11a
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s00yy1 := int(src.Y[s00i]) * 0x10100
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s10yy1 := int(src.Y[s10i]) * 0x10100
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s01yy1 := int(src.Y[s01i]) * 0x10100
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s11yy1 := int(src.Y[s11i]) * 0x10100
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
dst.Pix[d+3] = 0xff
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s00yy1 := int(src.Y[s00i]) * 0x10100
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s10yy1 := int(src.Y[s10i]) * 0x10100
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s01yy1 := int(src.Y[s01i]) * 0x10100
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s11yy1 := int(src.Y[s11i]) * 0x10100
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
if s11gu < 0 {
s11gu = 0
} else if s11gu > 0xffff {
s11gu = 0xffff
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
if s11bu < 0 {
s11bu = 0
} else if s11bu > 0xffff {
s11bu = 0xffff
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
dst.Pix[d+3] = 0xff
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00j := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + ((sx0)/2 - src.Rect.Min.X/2)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s00yy1 := int(src.Y[s00i]) * 0x10100
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10j := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + ((sx1)/2 - src.Rect.Min.X/2)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s10yy1 := int(src.Y[s10i]) * 0x10100
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s01j := ((sy1)/2-src.Rect.Min.Y/2)*src.CStride + ((sx0)/2 - src.Rect.Min.X/2)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s01yy1 := int(src.Y[s01i]) * 0x10100
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11j := ((sy1)/2-src.Rect.Min.Y/2)*src.CStride + ((sx1)/2 - src.Rect.Min.X/2)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s11yy1 := int(src.Y[s11i]) * 0x10100
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dst.Pix[d+3] = 0xff
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00j := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + (sx0 - src.Rect.Min.X)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s00yy1 := int(src.Y[s00i]) * 0x10100
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10j := ((sy0)/2-src.Rect.Min.Y/2)*src.CStride + (sx1 - src.Rect.Min.X)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s10yy1 := int(src.Y[s10i]) * 0x10100
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s01j := ((sy1)/2-src.Rect.Min.Y/2)*src.CStride + (sx0 - src.Rect.Min.X)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s01yy1 := int(src.Y[s01i]) * 0x10100
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11j := ((sy1)/2-src.Rect.Min.Y/2)*src.CStride + (sx1 - src.Rect.Min.X)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
s11yy1 := int(src.Y[s11i]) * 0x10100
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dst.Pix[d+3] = 0xff
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA()
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00a := float64(s00au)
s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA()
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a := float64(s10au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a = xFrac1*s00a + xFrac0*s10a
s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA()
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s01a := float64(s01au)
s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA()
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a := float64(s11au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = xFrac1*s01a + xFrac0*s11a
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = yFrac1*s10a + yFrac0*s11a
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA()
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00a := float64(s00au)
s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA()
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a := float64(s10au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a = xFrac1*s00a + xFrac0*s10a
s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA()
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s01a := float64(s01au)
s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA()
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a := float64(s11au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = xFrac1*s01a + xFrac0*s11a
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = yFrac1*s10a + yFrac0*s11a
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
srcMask, smp := opts.SrcMask, opts.SrcMaskP
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
dstMask, dmp := opts.DstMask, opts.DstMaskP
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
dstColorRGBA64 := &color.RGBA64{}
dstColor := color.Color(dstColorRGBA64)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00a := float64(s00au)
s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a := float64(s10au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a = xFrac1*s00a + xFrac0*s10a
s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s01a := float64(s01au)
s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a := float64(s11au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = xFrac1*s01a + xFrac0*s11a
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = yFrac1*s10a + yFrac0*s11a
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
pr := uint32(s11r)
pg := uint32(s11g)
pb := uint32(s11b)
pa := uint32(s11a)
draw: implement the Over operator. Change-Id: Id207b8f2fa5233175285800477e60f111ef4af63 Reviewed-on: https://go-review.googlesource.com/8744 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 11:58:30 +02:00
qr, qg, qb, qa := dst.At(dr.Min.X+int(dx), dr.Min.Y+int(dy)).RGBA()
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
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
}
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
srcMask, smp := opts.SrcMask, opts.SrcMaskP
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
dstMask, dmp := opts.DstMask, opts.DstMaskP
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
dstColorRGBA64 := &color.RGBA64{}
dstColor := color.Color(dstColorRGBA64)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
dyf := float64(dr.Min.Y+int(dy)) + 0.5
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00ru, s00gu, s00bu, s00au := src.At(sx0, sy0).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s00r := float64(s00ru)
s00g := float64(s00gu)
s00b := float64(s00bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s00a := float64(s00au)
s10ru, s10gu, s10bu, s10au := src.At(sx1, sy0).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r := float64(s10ru)
s10g := float64(s10gu)
s10b := float64(s10bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a := float64(s10au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s10r = xFrac1*s00r + xFrac0*s10r
s10g = xFrac1*s00g + xFrac0*s10g
s10b = xFrac1*s00b + xFrac0*s10b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s10a = xFrac1*s00a + xFrac0*s10a
s01ru, s01gu, s01bu, s01au := src.At(sx0, sy1).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s01r := float64(s01ru)
s01g := float64(s01gu)
s01b := float64(s01bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s01a := float64(s01au)
s11ru, s11gu, s11bu, s11au := src.At(sx1, sy1).RGBA()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r := float64(s11ru)
s11g := float64(s11gu)
s11b := float64(s11bu)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a := float64(s11au)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = xFrac1*s01r + xFrac0*s11r
s11g = xFrac1*s01g + xFrac0*s11g
s11b = xFrac1*s01b + xFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = xFrac1*s01a + xFrac0*s11a
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
s11r = yFrac1*s10r + yFrac0*s11r
s11g = yFrac1*s10g + yFrac0*s11g
s11b = yFrac1*s10b + yFrac0*s11b
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
s11a = yFrac1*s10a + yFrac0*s11a
draw: factor out some float64 to uint32 conversions. This will make the upcoming "implement masks" change easier. Change-Id: I2b316a0b25f98779d9cd076e64266c617464a08e Reviewed-on: https://go-review.googlesource.com/8999 Reviewed-by: Rob Pike <r@golang.org>
2015-04-17 09:57:53 +02:00
pr := uint32(s11r)
pg := uint32(s11g)
pb := uint32(s11b)
pa := uint32(s11a)
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
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)
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
func (z *kernelScaler) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
if z.dw != int32(dr.Dx()) || z.dh != int32(dr.Dy()) || z.sw != int32(sr.Dx()) || z.sh != int32(sr.Dy()) {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
z.kernel.Scale(dst, dr, src, sr, op, opts)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
return
}
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
var o Options
if opts != nil {
o = *opts
}
draw: add a fast path for an image.Rectangle DstMask. Change-Id: Id5227b9d217b56a342bc1ffc735dababa8a9e3e9 Reviewed-on: https://go-review.googlesource.com/9233 Reviewed-by: Rob Pike <r@golang.org>
2015-04-22 07:24:07 +02:00
// adr is the affected destination pixels.
adr := dst.Bounds().Intersect(dr)
adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
if adr.Empty() || sr.Empty() {
return
}
draw: add a fast path for an image.Rectangle DstMask. Change-Id: Id5227b9d217b56a342bc1ffc735dababa8a9e3e9 Reviewed-on: https://go-review.googlesource.com/9233 Reviewed-by: Rob Pike <r@golang.org>
2015-04-22 07:24:07 +02:00
// Make adr relative to dr.Min.
adr = adr.Sub(dr.Min)
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
if op == Over && o.SrcMask == nil && opaque(src) {
op = Src
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
if _, ok := src.(*image.Uniform); ok && o.DstMask == nil && o.SrcMask == nil && sr.In(src.Bounds()) {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
Draw(dst, dr, src, src.Bounds().Min, op)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
return
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
// 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()
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
// 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.
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
//
// Similarly, the fast paths assume that the masks are nil.
if o.SrcMask != nil || !sr.In(src.Bounds()) {
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scaleX_Image(tmp, src, sr, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
} else {
switch src := src.(type) {
case *image.Gray:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scaleX_Gray(tmp, src, sr, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case *image.NRGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scaleX_NRGBA(tmp, src, sr, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case *image.RGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scaleX_RGBA(tmp, src, sr, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case *image.YCbCr:
switch src.SubsampleRatio {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scaleX_Image(tmp, src, sr, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case image.YCbCrSubsampleRatio444:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scaleX_YCbCr444(tmp, src, sr, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case image.YCbCrSubsampleRatio422:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scaleX_YCbCr422(tmp, src, sr, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case image.YCbCrSubsampleRatio420:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scaleX_YCbCr420(tmp, src, sr, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case image.YCbCrSubsampleRatio440:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scaleX_YCbCr440(tmp, src, sr, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scaleX_Image(tmp, src, sr, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
}
}
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
if o.DstMask != nil {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
switch op {
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
case Over:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scaleY_Image_Over(dst, dr, adr, tmp, &o)
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
case Src:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
z.scaleY_Image_Src(dst, dr, adr, tmp, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
} else {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
switch op {
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
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)
}
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
image/draw: have Transform take a f64.Aff3 instead of a *f64.Aff3. It's more args (in terms of bytes), but fewer allocations (Transformer is an interface). Either way, it's not really that big of a deal, but the value instead of the pointer seems conceptually more correct. Change-Id: Ibea76da17cbda0d9633110fd56044b4e2c690e81 Reviewed-on: https://go-review.googlesource.com/12669 Reviewed-by: Rob Pike <r@golang.org>
2015-07-27 07:58:18 +02:00
func (q *Kernel) Transform(dst Image, s2d f64.Aff3, src image.Image, sr image.Rectangle, op Op, opts *Options) {
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
var o Options
if opts != nil {
o = *opts
}
image/draw: have Transform take a f64.Aff3 instead of a *f64.Aff3. It's more args (in terms of bytes), but fewer allocations (Transformer is an interface). Either way, it's not really that big of a deal, but the value instead of the pointer seems conceptually more correct. Change-Id: Ibea76da17cbda0d9633110fd56044b4e2c690e81 Reviewed-on: https://go-review.googlesource.com/12669 Reviewed-by: Rob Pike <r@golang.org>
2015-07-27 07:58:18 +02:00
dr := transformRect(&s2d, &sr)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
// adr is the affected destination pixels.
adr := dst.Bounds().Intersect(dr)
draw: add a fast path for an image.Rectangle DstMask. Change-Id: Id5227b9d217b56a342bc1ffc735dababa8a9e3e9 Reviewed-on: https://go-review.googlesource.com/9233 Reviewed-by: Rob Pike <r@golang.org>
2015-04-22 07:24:07 +02:00
adr, o.DstMask = clipAffectedDestRect(adr, o.DstMask, o.DstMaskP)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
if adr.Empty() || sr.Empty() {
return
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
if op == Over && o.SrcMask == nil && opaque(src) {
op = Src
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
image/draw: have Transform take a f64.Aff3 instead of a *f64.Aff3. It's more args (in terms of bytes), but fewer allocations (Transformer is an interface). Either way, it's not really that big of a deal, but the value instead of the pointer seems conceptually more correct. Change-Id: Ibea76da17cbda0d9633110fd56044b4e2c690e81 Reviewed-on: https://go-review.googlesource.com/12669 Reviewed-by: Rob Pike <r@golang.org>
2015-07-27 07:58:18 +02:00
d2s := invert(&s2d)
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
// 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.
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
if u, ok := src.(*image.Uniform); ok && o.DstMask != nil && o.SrcMask != nil && sr.In(src.Bounds()) {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, op)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
return
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
// 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.
draw: add mask fields to Options. This change only adds the fields, more or less. Follow-up changes will actually honor the masks. Change-Id: I81411dc1aac4b3c846dcdf13e2cb0b5cd60fb2b4 Reviewed-on: https://go-review.googlesource.com/8902 Reviewed-by: Rob Pike <r@golang.org>
2015-04-14 08:23:36 +02:00
//
// Similarly, the fast paths assume that the masks are nil.
if o.DstMask != nil || o.SrcMask != nil || !sr.In(src.Bounds()) {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
switch op {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case Over:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case Src:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
}
} else {
draw: make op a mandatory argument, not optional. Change-Id: Ic08ce587cf458444b098b752f0fa7ab16d43c914 Reviewed-on: https://go-review.googlesource.com/9468 Reviewed-by: Rob Pike <r@golang.org>
2015-04-29 09:05:36 +02:00
switch op {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case Over:
switch dst := dst.(type) {
case *image.RGBA:
switch src := src.(type) {
case *image.NRGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_RGBA_NRGBA_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case *image.RGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_RGBA_RGBA_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_RGBA_Image_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
}
default:
switch src := src.(type) {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case Src:
switch dst := dst.(type) {
case *image.RGBA:
switch src := src.(type) {
case *image.Gray:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_RGBA_Gray_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case *image.NRGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_RGBA_NRGBA_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case *image.RGBA:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_RGBA_RGBA_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case *image.YCbCr:
switch src.SubsampleRatio {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case image.YCbCrSubsampleRatio444:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_RGBA_YCbCr444_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case image.YCbCrSubsampleRatio422:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_RGBA_YCbCr422_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case image.YCbCrSubsampleRatio420:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_RGBA_YCbCr420_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
case image.YCbCrSubsampleRatio440:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_RGBA_YCbCr440_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
}
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
}
default:
switch src := src.(type) {
default:
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
q.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale, &o)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
}
}
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (z *kernelScaler) scaleX_Gray(tmp [][4]float64, src *image.Gray, sr image.Rectangle, opts *Options) {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
pr *= s.invTotalWeightFFFF
tmp[t] = [4]float64{
pr,
pr,
pr,
1,
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
t++
}
}
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (z *kernelScaler) scaleX_NRGBA(tmp [][4]float64, src *image.NRGBA, sr image.Rectangle, opts *Options) {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
tmp[t] = [4]float64{
pr * s.invTotalWeightFFFF,
pg * s.invTotalWeightFFFF,
pb * s.invTotalWeightFFFF,
pa * s.invTotalWeightFFFF,
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
t++
}
}
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (z *kernelScaler) scaleX_RGBA(tmp [][4]float64, src *image.RGBA, sr image.Rectangle, opts *Options) {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
t := 0
for y := int32(0); y < z.sh; y++ {
for _, s := range z.horizontal.sources {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
var pr, pg, pb, pa float64
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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,
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
t++
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (z *kernelScaler) scaleX_YCbCr444(tmp [][4]float64, src *image.YCbCr, sr image.Rectangle, opts *Options) {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
pr += float64(pru) * c.weight
pg += float64(pgu) * c.weight
pb += float64(pbu) * c.weight
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
tmp[t] = [4]float64{
pr * s.invTotalWeightFFFF,
pg * s.invTotalWeightFFFF,
pb * s.invTotalWeightFFFF,
1,
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
t++
}
}
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (z *kernelScaler) scaleX_YCbCr422(tmp [][4]float64, src *image.YCbCr, sr image.Rectangle, opts *Options) {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
pr += float64(pru) * c.weight
pg += float64(pgu) * c.weight
pb += float64(pbu) * c.weight
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
tmp[t] = [4]float64{
pr * s.invTotalWeightFFFF,
pg * s.invTotalWeightFFFF,
pb * s.invTotalWeightFFFF,
1,
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
t++
}
}
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (z *kernelScaler) scaleX_YCbCr420(tmp [][4]float64, src *image.YCbCr, sr image.Rectangle, opts *Options) {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
tmp[t] = [4]float64{
pr * s.invTotalWeightFFFF,
pg * s.invTotalWeightFFFF,
pb * s.invTotalWeightFFFF,
1,
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
t++
}
}
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (z *kernelScaler) scaleX_YCbCr440(tmp [][4]float64, src *image.YCbCr, sr image.Rectangle, opts *Options) {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
pr += float64(pru) * c.weight
pg += float64(pgu) * c.weight
pb += float64(pbu) * c.weight
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
tmp[t] = [4]float64{
pr * s.invTotalWeightFFFF,
pg * s.invTotalWeightFFFF,
pb * s.invTotalWeightFFFF,
1,
}
t++
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (z *kernelScaler) scaleX_Image(tmp [][4]float64, src image.Image, sr image.Rectangle, opts *Options) {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
t := 0
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
srcMask, smp := opts.SrcMask, opts.SrcMaskP
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
pr += float64(pru) * c.weight
pg += float64(pgu) * c.weight
pb += float64(pbu) * c.weight
pa += float64(pau) * c.weight
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
tmp[t] = [4]float64{
pr * s.invTotalWeightFFFF,
pg * s.invTotalWeightFFFF,
pb * s.invTotalWeightFFFF,
pa * s.invTotalWeightFFFF,
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
t++
}
}
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (z *kernelScaler) scaleY_RGBA_Over(dst *image.RGBA, dr, adr image.Rectangle, tmp [][4]float64, opts *Options) {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: clamp kernel output so red, green and blue <= alpha. The raw computation can produce red > alpha when some weights are negative. Change-Id: Ic6701354770f012d3ef21a390a8400e14e9d1e25 Reviewed-on: https://go-review.googlesource.com/8740 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 05:05:20 +02:00
if pr > pa {
pr = pa
}
if pg > pa {
pg = pa
}
if pb > pa {
pb = pa
}
draw: implement the Over operator. Change-Id: Id207b8f2fa5233175285800477e60f111ef4af63 Reviewed-on: https://go-review.googlesource.com/8744 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 11:58:30 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
d += dst.Stride
}
}
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (z *kernelScaler) scaleY_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, tmp [][4]float64, opts *Options) {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: clamp kernel output so red, green and blue <= alpha. The raw computation can produce red > alpha when some weights are negative. Change-Id: Ic6701354770f012d3ef21a390a8400e14e9d1e25 Reviewed-on: https://go-review.googlesource.com/8740 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 05:05:20 +02:00
if pr > pa {
pr = pa
}
if pg > pa {
pg = pa
}
if pb > pa {
pb = pa
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
}
}
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (z *kernelScaler) scaleY_Image_Over(dst Image, dr, adr image.Rectangle, tmp [][4]float64, opts *Options) {
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
dstMask, dmp := opts.DstMask, opts.DstMaskP
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: clamp kernel output so red, green and blue <= alpha. The raw computation can produce red > alpha when some weights are negative. Change-Id: Ic6701354770f012d3ef21a390a8400e14e9d1e25 Reviewed-on: https://go-review.googlesource.com/8740 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 05:05:20 +02:00
if pr > pa {
pr = pa
}
if pg > pa {
pg = pa
}
if pb > pa {
pb = pa
}
draw: implement the Over operator. Change-Id: Id207b8f2fa5233175285800477e60f111ef4af63 Reviewed-on: https://go-review.googlesource.com/8744 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 11:58:30 +02:00
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))
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
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
}
draw: implement the Over operator. Change-Id: Id207b8f2fa5233175285800477e60f111ef4af63 Reviewed-on: https://go-review.googlesource.com/8744 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 11:58:30 +02:00
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)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(adr.Min.Y+dy), dstColor)
}
}
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
func (z *kernelScaler) scaleY_Image_Src(dst Image, dr, adr image.Rectangle, tmp [][4]float64, opts *Options) {
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
dstMask, dmp := opts.DstMask, opts.DstMaskP
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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] {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
var pr, pg, pb, pa float64
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
draw: clamp kernel output so red, green and blue <= alpha. The raw computation can produce red > alpha when some weights are negative. Change-Id: Ic6701354770f012d3ef21a390a8400e14e9d1e25 Reviewed-on: https://go-review.googlesource.com/8740 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 05:05:20 +02:00
if pr > pa {
pr = pa
}
if pg > pa {
pg = pa
}
if pb > pa {
pb = pa
}
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
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)
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// 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
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
var pr float64
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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 {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
pi := (ky-src.Rect.Min.Y)*src.Stride + (kx - src.Rect.Min.X)
pru := uint32(src.Pix[pi]) * 0x101
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
pr += float64(pru) * w
}
draw: switch on the Op compositing operator. This change only *prepares* the codegen to handle multiple Ops. The actual generated code still only supports one Op (Src) and not the other (Over). A follow-up change will add Over. This Op switch (an eventual x2 multiplier in the amount of code generated) should be the last of the codegen LoC multipliers. The dst and src mask options will be implemented in the slow path fallback. Change-Id: Iecbcc6fad063e2aac36d78d5380c0a0947c709df Reviewed-on: https://go-review.googlesource.com/8488 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 03:22:25 +02:00
}
}
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
}
draw: add Transformer and Option types. Just stub implementations for now. Actual implementations will be follow-up changes. Change-Id: Id21d9042a2073c2dc0f78c9977c4940f000a41df Reviewed-on: https://go-review.googlesource.com/6805 Reviewed-by: Rob Pike <r@golang.org>
2015-03-05 05:46:57 +01:00
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// 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
draw: generate code paths for image.Gray sources. Optimizing this code path will be follow-up changes. Change-Id: Ifece6c7d3685bb8f2d20cf8828a121c9ff346434 Reviewed-on: https://go-review.googlesource.com/6238 Reviewed-by: Rob Pike <r@golang.org>
2015-02-28 06:05:58 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// 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
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
for x := range xWeights[:jx-ix] {
xWeights[x] /= totalXWeight
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
yWeights[ky-iy] = yWeight
totalYWeight += yWeight
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
for y := range yWeights[:jy-iy] {
yWeights[y] /= totalYWeight
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
var pr, pg, pb, pa float64
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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 {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
pr += float64(pru) * w
pg += float64(pgu) * w
pb += float64(pbu) * w
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
pa += float64(pau) * w
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: clamp kernel output so red, green and blue <= alpha. The raw computation can produce red > alpha when some weights are negative. Change-Id: Ic6701354770f012d3ef21a390a8400e14e9d1e25 Reviewed-on: https://go-review.googlesource.com/8740 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 05:05:20 +02:00
if pr > pa {
pr = pa
}
if pg > pa {
pg = pa
}
if pb > pa {
pb = pa
}
draw: implement the Over operator. Change-Id: Id207b8f2fa5233175285800477e60f111ef4af63 Reviewed-on: https://go-review.googlesource.com/8744 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 11:58:30 +02:00
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)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// 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
}
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
xWeights := make([]float64, 1+2*int(math.Ceil(xHalfWidth)))
yWeights := make([]float64, 1+2*int(math.Ceil(yHalfWidth)))
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// 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
}
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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)
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
xWeights[kx-ix] = xWeight
totalXWeight += xWeight
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
for x := range xWeights[:jx-ix] {
xWeights[x] /= totalXWeight
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
sy += float64(bias.Y)
sy -= 0.5
iy := int(math.Floor(sy - yHalfWidth))
if iy < sr.Min.Y {
iy = sr.Min.Y
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
jy := int(math.Ceil(sy + yHalfWidth))
if jy > sr.Max.Y {
jy = sr.Max.Y
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
var pr, pg, pb, pa float64
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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 {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
pr += float64(pru) * w
pg += float64(pgu) * w
pb += float64(pbu) * w
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
pa += float64(pau) * w
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
}
}
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: clamp kernel output so red, green and blue <= alpha. The raw computation can produce red > alpha when some weights are negative. Change-Id: Ic6701354770f012d3ef21a390a8400e14e9d1e25 Reviewed-on: https://go-review.googlesource.com/8740 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 05:05:20 +02:00
if pr > pa {
pr = pa
}
if pg > pa {
pg = pa
}
if pb > pa {
pb = pa
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dst.Pix[d+0] = uint8(fffftou(pr) >> 8)
dst.Pix[d+1] = uint8(fffftou(pg) >> 8)
dst.Pix[d+2] = uint8(fffftou(pb) >> 8)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
dst.Pix[d+3] = uint8(fffftou(pa) >> 8)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
// 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
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
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]
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) {
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
continue
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
// TODO: adjust the bias so that we can use int(f) instead
// of math.Floor(f) and math.Ceil(f).
sx += float64(bias.X)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
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
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
sy += float64(bias.Y)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
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
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
var pr, pg, pb, pa float64
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for ky := iy; ky < jy; ky++ {
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
if yWeight := yWeights[ky-iy]; yWeight != 0 {
for kx := ix; kx < jx; kx++ {
if w := xWeights[kx-ix] * yWeight; w != 0 {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
pr += float64(pru) * w
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
pg += float64(pgu) * w
pb += float64(pbu) * w
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
pa += float64(pau) * w
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
}
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
}
draw: clamp kernel output so red, green and blue <= alpha. The raw computation can produce red > alpha when some weights are negative. Change-Id: Ic6701354770f012d3ef21a390a8400e14e9d1e25 Reviewed-on: https://go-review.googlesource.com/8740 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 05:05:20 +02:00
if pr > pa {
pr = pa
}
if pg > pa {
pg = pa
}
if pb > pa {
pb = pa
}
draw: implement the Over operator. Change-Id: Id207b8f2fa5233175285800477e60f111ef4af63 Reviewed-on: https://go-review.googlesource.com/8744 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 11:58:30 +02:00
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)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
// 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
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
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]
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) {
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
continue
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
// TODO: adjust the bias so that we can use int(f) instead
// of math.Floor(f) and math.Ceil(f).
sx += float64(bias.X)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
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
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
sy += float64(bias.Y)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
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
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
var pr, pg, pb, pa float64
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for ky := iy; ky < jy; ky++ {
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
if yWeight := yWeights[ky-iy]; yWeight != 0 {
for kx := ix; kx < jx; kx++ {
if w := xWeights[kx-ix] * yWeight; w != 0 {
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
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
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
pr += float64(pru) * w
pg += float64(pgu) * w
pb += float64(pbu) * w
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
pa += float64(pau) * w
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
}
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
}
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
draw: clamp kernel output so red, green and blue <= alpha. The raw computation can produce red > alpha when some weights are negative. Change-Id: Ic6701354770f012d3ef21a390a8400e14e9d1e25 Reviewed-on: https://go-review.googlesource.com/8740 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 05:05:20 +02:00
if pr > pa {
pr = pa
}
if pg > pa {
pg = pa
}
if pb > pa {
pb = pa
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
dst.Pix[d+0] = uint8(fffftou(pr) >> 8)
dst.Pix[d+1] = uint8(fffftou(pg) >> 8)
dst.Pix[d+2] = uint8(fffftou(pb) >> 8)
draw: substitute Src for Over when the source image is completely opaque. The two Ops are equivalent, but Src is faster. Change-Id: I2c73a13755047c224c71fb5af786875f02681de9 Reviewed-on: https://go-review.googlesource.com/8640 Reviewed-by: Rob Pike <r@golang.org>
2015-04-08 12:47:13 +02:00
dst.Pix[d+3] = uint8(fffftou(pa) >> 8)
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
// 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
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
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]
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) {
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
continue
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
// TODO: adjust the bias so that we can use int(f) instead
// of math.Floor(f) and math.Ceil(f).
sx += float64(bias.X)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
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
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
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
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for x := range xWeights[:jx-ix] {
xWeights[x] /= totalXWeight
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
sy += float64(bias.Y)
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
sy -= 0.5
iy := int(math.Floor(sy - yHalfWidth))
if iy < sr.Min.Y {
iy = sr.Min.Y
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
jy := int(math.Ceil(sy + yHalfWidth))
if jy > sr.Max.Y {
jy = sr.Max.Y
draw: factor out the Scale implementations. This is just a copy/paste/rename in anticipation of automatically generating fast-path code for specific dst-image types and src-image types, a la the standard library's image/draw package. Change-Id: If6385b347cb5e1d134b0ce841ef38ed4450a6fef Reviewed-on: https://go-review.googlesource.com/5252 Reviewed-by: David Symonds <dsymonds@golang.org>
2015-02-19 05:53:02 +01:00
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
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
draw: generate impl.go type switches. This just the type switches to concrete-type-specific methods. Generating RGBA- or YCbCr-specific code instead of calling the general-purpose At and Set methods will be follow-up changes. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 5771212 5766160 -0.09% BenchmarkScaleLargeDownAB 14057354 14023083 -0.24% BenchmarkScaleLargeDownBL 1349968635 1347746478 -0.16% BenchmarkScaleLargeDownCR 2687753329 2678909022 -0.33% BenchmarkScaleDownNN 1802408 1808723 +0.35% BenchmarkScaleDownAB 4352978 4284878 -1.56% BenchmarkScaleDownBL 29760913 29522171 -0.80% BenchmarkScaleDownCR 57666917 56334005 -2.31% BenchmarkScaleUpNN 88886450 89235790 +0.39% BenchmarkScaleUpAB 214687758 213797857 -0.41% BenchmarkScaleUpBL 119588096 119846371 +0.22% BenchmarkScaleUpCR 179784111 180662030 +0.49% BenchmarkScaleSrcUniform 4128528 3855385 -6.62% BenchmarkScaleSrcNRGBA 13275457 13375039 +0.75% BenchmarkScaleSrcRGBA 13333672 12812895 -3.91% BenchmarkScaleSrcYCbCr 14321945 14139071 -1.28% Change-Id: I28025c3b49186a12d20ee0182a4c8ff9b036d0ae Reviewed-on: https://go-review.googlesource.com/5712 Reviewed-by: Rob Pike <r@golang.org>
2015-02-24 05:28:16 +01:00
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
var pr, pg, pb float64
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
for ky := iy; ky < jy; ky++ {
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
if yWeight := yWeights[ky-iy]; yWeight != 0 {
for kx := ix; kx < jx; kx++ {
if w := xWeights[kx-ix] * yWeight; w != 0 {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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
}
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
pr += float64(pru) * w
pg += float64(pgu) * w
pb += float64(pbu) * w
}
}
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
}
draw: distinguish YCbCr fast paths by their chroma subsample ratios. These code paths aren't actually fast yet. That will be a follow-up change. Change-Id: I814992573cc6af422e49d0ddf336003e662897a5 Reviewed-on: https://go-review.googlesource.com/7791 Reviewed-by: Rob Pike <r@golang.org>
2015-03-19 01:04:55 +01:00
dst.Pix[d+0] = uint8(fffftou(pr) >> 8)
dst.Pix[d+1] = uint8(fffftou(pg) >> 8)
dst.Pix[d+2] = uint8(fffftou(pb) >> 8)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dst.Pix[d+3] = 0xff
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
// 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
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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]
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) {
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
continue
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
// TODO: adjust the bias so that we can use int(f) instead
// of math.Floor(f) and math.Ceil(f).
sx += float64(bias.X)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
sy += float64(bias.Y)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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
}
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
var pr, pg, pb float64
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
for ky := iy; ky < jy; ky++ {
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
pj := (ky-src.Rect.Min.Y)*src.CStride + ((kx)/2 - src.Rect.Min.X/2)
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
pcb1 := int(src.Cb[pj]) - 128
pcr1 := int(src.Cr[pj]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
}
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
if pgu < 0 {
pgu = 0
} else if pgu > 0xffff {
pgu = 0xffff
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
}
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
if pbu < 0 {
pbu = 0
} else if pbu > 0xffff {
pbu = 0xffff
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
}
pr += float64(pru) * w
pg += float64(pgu) * w
pb += float64(pbu) * w
}
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
}
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
}
dst.Pix[d+0] = uint8(fffftou(pr) >> 8)
dst.Pix[d+1] = uint8(fffftou(pg) >> 8)
dst.Pix[d+2] = uint8(fffftou(pb) >> 8)
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
dst.Pix[d+3] = 0xff
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
// 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
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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]
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) {
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
continue
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
// TODO: adjust the bias so that we can use int(f) instead
// of math.Floor(f) and math.Ceil(f).
sx += float64(bias.X)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
sy += float64(bias.Y)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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
}
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
var pr, pg, pb float64
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
for ky := iy; ky < jy; ky++ {
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
pj := ((ky)/2-src.Rect.Min.Y/2)*src.CStride + ((kx)/2 - src.Rect.Min.X/2)
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
pcb1 := int(src.Cb[pj]) - 128
pcr1 := int(src.Cr[pj]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
}
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
if pgu < 0 {
pgu = 0
} else if pgu > 0xffff {
pgu = 0xffff
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
}
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
if pbu < 0 {
pbu = 0
} else if pbu > 0xffff {
pbu = 0xffff
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
}
pr += float64(pru) * w
pg += float64(pgu) * w
pb += float64(pbu) * w
}
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
}
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
}
dst.Pix[d+0] = uint8(fffftou(pr) >> 8)
dst.Pix[d+1] = uint8(fffftou(pg) >> 8)
dst.Pix[d+2] = uint8(fffftou(pb) >> 8)
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
dst.Pix[d+3] = 0xff
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
// 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
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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]
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) {
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
continue
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
// TODO: adjust the bias so that we can use int(f) instead
// of math.Floor(f) and math.Ceil(f).
sx += float64(bias.X)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
sy += float64(bias.Y)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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
}
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
var pr, pg, pb float64
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
for ky := iy; ky < jy; ky++ {
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
pj := ((ky)/2-src.Rect.Min.Y/2)*src.CStride + (kx - src.Rect.Min.X)
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
// This is an inline version of image/color/ycbcr.go's YCbCr.RGBA method.
draw: tweak the YCbCr to RGBA conversion formula. This is the golang.org/x equivalent of the golang.org/cl/12220 change to the standard library. Change-Id: I220d1398902dec374472ef5b08db8501607cc971 Reviewed-on: https://go-review.googlesource.com/12222 Reviewed-by: Rob Pike <r@golang.org>
2015-07-15 07:03:37 +02:00
pyy1 := int(src.Y[pi]) * 0x10100
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
pcb1 := int(src.Cb[pj]) - 128
pcr1 := int(src.Cr[pj]) - 128
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
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
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
}
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
if pgu < 0 {
pgu = 0
} else if pgu > 0xffff {
pgu = 0xffff
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
}
draw: update the inlined YCbCr.RGBA code to use 16 bit color. This matches the standard library change at https://go-review.googlesource.com/#/c/8073/ Change-Id: I216028e18678a70e449167cd9ab910c63d37adcc Reviewed-on: https://go-review.googlesource.com/8075 Reviewed-by: Rob Pike <r@golang.org>
2015-03-26 09:33:18 +01:00
if pbu < 0 {
pbu = 0
} else if pbu > 0xffff {
pbu = 0xffff
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
}
pr += float64(pru) * w
pg += float64(pgu) * w
pb += float64(pbu) * w
}
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
}
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
}
dst.Pix[d+0] = uint8(fffftou(pr) >> 8)
dst.Pix[d+1] = uint8(fffftou(pg) >> 8)
dst.Pix[d+2] = uint8(fffftou(pb) >> 8)
draw: add Scale and Transform fast paths for YCbCr src images. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 3239565 1044458 -67.76% BenchmarkScaleLargeDownAB 12162059 3205972 -73.64% BenchmarkScaleLargeDownBL 1437923310 358229213 -75.09% BenchmarkScaleLargeDownCR 2844139449 651228380 -77.10% BenchmarkScaleSrcYCbCr 12413692 3176042 -74.42% BenchmarkTformABSrcYCbCr 8363947 2163052 -74.14% BenchmarkTformCRSrcYCbCr 49944171 11652821 -76.67% Change-Id: I8cd5ab20aa1f516114599690cab037441a328aec Reviewed-on: https://go-review.googlesource.com/7796 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 00:14:03 +01:00
dst.Pix[d+3] = 0xff
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
// 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
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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]
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) {
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
continue
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
// TODO: adjust the bias so that we can use int(f) instead
// of math.Floor(f) and math.Ceil(f).
sx += float64(bias.X)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
sy += float64(bias.Y)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
var pr, pg, pb, pa float64
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
for ky := iy; ky < jy; ky++ {
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
if yWeight := yWeights[ky-iy]; yWeight != 0 {
for kx := ix; kx < jx; kx++ {
if w := xWeights[kx-ix] * yWeight; w != 0 {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
pru, pgu, pbu, pau := src.At(kx, ky).RGBA()
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
pr += float64(pru) * w
pg += float64(pgu) * w
pb += float64(pbu) * w
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
pa += float64(pau) * w
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
}
draw: inline the generated YCbCrToRGB calls. benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1302036 1168046 -10.29% BenchmarkScaleLargeDownAB 3995006 3447621 -13.70% BenchmarkScaleLargeDownBL 455470707 387598726 -14.90% BenchmarkScaleLargeDownCR 818317661 679199442 -17.00% BenchmarkScaleSrcYCbCr 3965076 3422325 -13.69% BenchmarkTformABSrcYCbCr 2921253 2551934 -12.64% BenchmarkTformCRSrcYCbCr 14839184 12263956 -17.35% Change-Id: I60dcb5c00a30709fdc6616cbc8c2fc48ec3a8b14 Reviewed-on: https://go-review.googlesource.com/7921 Reviewed-by: Rob Pike <r@golang.org>
2015-03-21 06:55:24 +01:00
}
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
}
draw: clamp kernel output so red, green and blue <= alpha. The raw computation can produce red > alpha when some weights are negative. Change-Id: Ic6701354770f012d3ef21a390a8400e14e9d1e25 Reviewed-on: https://go-review.googlesource.com/8740 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 05:05:20 +02:00
if pr > pa {
pr = pa
}
if pg > pa {
pg = pa
}
if pb > pa {
pb = pa
}
draw: implement the Over operator. Change-Id: Id207b8f2fa5233175285800477e60f111ef4af63 Reviewed-on: https://go-review.googlesource.com/8744 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 11:58:30 +02:00
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)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
// 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
draw: inline the generated PixOffset calls. Only the YCbCr benchmarks show significant changes. The other benchmark changes look noisy. The PixOffset and YOffset calls were previously already inlined by the gc compiler. COffset was different because it's more complicated than YOffset, and the switch inside the COffset body is redundant when you already know the src image sratio. http://golang.org/src/image/ycbcr.go?s=2377:2414#L77 benchmark old ns/op new ns/op delta BenchmarkScaleLargeDownNN 1037504 908236 -12.46% BenchmarkScaleLargeDownAB 3196568 2735776 -14.42% BenchmarkScaleLargeDownBL 357165552 311463393 -12.80% BenchmarkScaleLargeDownCR 649403305 544985134 -16.08% BenchmarkScaleSrcYCbCr 3204063 2699147 -15.76% BenchmarkTformABSrcYCbCr 2155142 1968540 -8.66% BenchmarkTformCRSrcYCbCr 11672625 9865358 -15.48% Change-Id: Ifa109363a1282ab114b2fdb0b577dcafef927333 Reviewed-on: https://go-review.googlesource.com/7880 Reviewed-by: Rob Pike <r@golang.org>
2015-03-20 06:36:51 +01:00
d := (dr.Min.Y+int(dy)-dst.Rect.Min.Y)*dst.Stride + (dr.Min.X+adr.Min.X-dst.Rect.Min.X)*4
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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]
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) {
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
continue
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
// TODO: adjust the bias so that we can use int(f) instead
// of math.Floor(f) and math.Ceil(f).
sx += float64(bias.X)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
sy += float64(bias.Y)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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++ {
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
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
}
}
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
}
draw: clamp kernel output so red, green and blue <= alpha. The raw computation can produce red > alpha when some weights are negative. Change-Id: Ic6701354770f012d3ef21a390a8400e14e9d1e25 Reviewed-on: https://go-review.googlesource.com/8740 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 05:05:20 +02:00
if pr > pa {
pr = pa
}
if pg > pa {
pg = pa
}
if pb > pa {
pb = pa
}
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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)
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
// 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)))
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
srcMask, smp := opts.SrcMask, opts.SrcMaskP
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
dstMask, dmp := opts.DstMask, opts.DstMaskP
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
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()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
pr += float64(pru) * w
pg += float64(pgu) * w
pb += float64(pbu) * w
pa += float64(pau) * w
}
}
}
}
draw: clamp kernel output so red, green and blue <= alpha. The raw computation can produce red > alpha when some weights are negative. Change-Id: Ic6701354770f012d3ef21a390a8400e14e9d1e25 Reviewed-on: https://go-review.googlesource.com/8740 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 05:05:20 +02:00
if pr > pa {
pr = pa
}
if pg > pa {
pg = pa
}
if pb > pa {
pb = pa
}
draw: implement the Over operator. Change-Id: Id207b8f2fa5233175285800477e60f111ef4af63 Reviewed-on: https://go-review.googlesource.com/8744 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 11:58:30 +02:00
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))
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
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
}
draw: implement the Over operator. Change-Id: Id207b8f2fa5233175285800477e60f111ef4af63 Reviewed-on: https://go-review.googlesource.com/8744 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 11:58:30 +02:00
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)
draw: generate code for op == Over. This change just does the mechanical codegen for the op == Over cases. The actual compositing operator is still effectively Src. Fixing that, which is less mechanical, will be a follow-up change. Change-Id: I87805114d49e7ce7087066187a2f4c722a883c01 Reviewed-on: https://go-review.googlesource.com/8524 Reviewed-by: Rob Pike <r@golang.org>
2015-04-07 08:22:05 +02:00
dst.Set(dr.Min.X+int(dx), dr.Min.Y+int(dy), dstColor)
}
}
}
draw: plumb the Options through to the type-specific code. It'll only be used by the fallback code paths, but it's easiest if all code paths take the extra argument. Change-Id: I09c4067df6af7c4cd270e8ffcad96d1d8af29057 Reviewed-on: https://go-review.googlesource.com/8909 Reviewed-by: Rob Pike <r@golang.org>
2015-04-16 08:17:58 +02:00
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) {
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
// 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)))
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
srcMask, smp := opts.SrcMask, opts.SrcMaskP
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
dstMask, dmp := opts.DstMask, opts.DstMaskP
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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]
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
if !(image.Point{int(sx) + bias.X, int(sy) + bias.Y}).In(sr) {
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
continue
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
// TODO: adjust the bias so that we can use int(f) instead
// of math.Floor(f) and math.Ceil(f).
sx += float64(bias.X)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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
}
draw: eliminate some math.Floor calls in Transform methods. benchmark old ns/op new ns/op delta BenchmarkTformNNSrcRGBA 524533 293230 -44.10% BenchmarkTformNNSrcUniform 362974 149389 -58.84% BenchmarkTformABSrcGray 827461 427720 -48.31% BenchmarkTformABSrcNRGBA 1286930 919391 -28.56% BenchmarkTformABSrcRGBA 1115444 794334 -28.79% BenchmarkTformABSrcYCbCr 1732420 1379846 -20.35% BenchmarkTformCRSrcGray 3629048 3467404 -4.45% BenchmarkTformCRSrcNRGBA 7569407 7418874 -1.99% BenchmarkTformCRSrcRGBA 7552459 7432745 -1.59% BenchmarkTformCRSrcYCbCr 8072351 7854715 -2.70% Change-Id: I6c01e631d9f88c36ae99d0cd181104ad5ac48db0 Reviewed-on: https://go-review.googlesource.com/7926 Reviewed-by: Rob Pike <r@golang.org>
2015-03-23 03:30:31 +01:00
sy += float64(bias.Y)
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
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++ {
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
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()
draw: implement srcMask. Change-Id: Ibf710521f466847afaf2d005dc8a2bb817169298 Reviewed-on: https://go-review.googlesource.com/9276 Reviewed-by: Rob Pike <r@golang.org>
2015-04-24 06:45:24 +02:00
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
}
draw: optimize some multiply-by-zeroes in Kernel.Transform. benchmark old ns/op new ns/op delta BenchmarkTformCRSrcGray 5096041 4820642 -5.40% BenchmarkTformCRSrcNRGBA 10476578 8414331 -19.68% BenchmarkTformCRSrcRGBA 10361135 7954413 -23.23% BenchmarkTformCRSrcYCbCr 11952218 9824899 -17.80% Change-Id: I8b4cfe68ecae85e447ae65ceecf185261445a8a2 Reviewed-on: https://go-review.googlesource.com/7991 Reviewed-by: Rob Pike <r@golang.org>
2015-03-24 10:16:40 +01:00
pr += float64(pru) * w
pg += float64(pgu) * w
pb += float64(pbu) * w
pa += float64(pau) * w
}
}
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
}
draw: clamp kernel output so red, green and blue <= alpha. The raw computation can produce red > alpha when some weights are negative. Change-Id: Ic6701354770f012d3ef21a390a8400e14e9d1e25 Reviewed-on: https://go-review.googlesource.com/8740 Reviewed-by: Rob Pike <r@golang.org>
2015-04-10 05:05:20 +02:00
if pr > pa {
pr = pa
}
if pg > pa {
pg = pa
}
if pb > pa {
pb = pa
}
draw: implement dstMask. Change-Id: Id63695c3cef67fbe79fa1fbe916b85108f401093 Reviewed-on: https://go-review.googlesource.com/9191 Reviewed-by: Rob Pike <r@golang.org>
2015-04-21 06:26:44 +02:00
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)
}
draw: implement Kernel.Transform. Also fix the NN and ABL fast paths to only apply if we can access the Pix elements without src-bounds checking. Change-Id: Ie9fc96b28e0665df49d00c4c53cb81385faee4db Reviewed-on: https://go-review.googlesource.com/7675 Reviewed-by: Rob Pike <r@golang.org>
2015-03-17 08:46:52 +01:00
}
}
}
Reference in New Issue Copy Permalink