diff --git a/draw/gen.go b/draw/gen.go
index 6efdafa..3ec18a1 100644
--- a/draw/gen.go
+++ b/draw/gen.go
@@ -71,6 +71,7 @@
 		"420",
 		"440",
 	}
+	ops = []string{"Src"} // TODO: add "Over".
 )
 
 func init() {
@@ -95,17 +96,21 @@
 	sType    string
 	sratio   string
 	receiver string
+	op       string
 }
 
 func gen(w *bytes.Buffer, receiver string, codes ...string) {
 	expn(w, codeRoot, &data{receiver: receiver})
 	for _, code := range codes {
 		for _, t := range dsTypes {
-			expn(w, code, &data{
-				dType:    t.dType,
-				sType:    t.sType,
-				receiver: receiver,
-			})
+			for _, op := range ops {
+				expn(w, code, &data{
+					dType:    t.dType,
+					sType:    t.sType,
+					receiver: receiver,
+					op:       op,
+				})
+			}
 		}
 	}
 }
@@ -118,15 +123,21 @@
 		})
 	}
 	for _, dType := range dTypes {
-		expn(w, codeKernelScaleLeafY, &data{
-			dType: dType,
-		})
+		for _, op := range ops {
+			expn(w, codeKernelScaleLeafY, &data{
+				dType: dType,
+				op:    op,
+			})
+		}
 	}
 	for _, t := range dsTypes {
-		expn(w, codeKernelTransformLeaf, &data{
-			dType: t.dType,
-			sType: t.sType,
-		})
+		for _, op := range ops {
+			expn(w, codeKernelTransformLeaf, &data{
+				dType: t.dType,
+				sType: t.sType,
+				op:    op,
+			})
+		}
 	}
 }
 
@@ -192,13 +203,15 @@
 		return prefix + relName(d.sType) + suffix
 	case "receiver":
 		return prefix + d.receiver + suffix
+	case "op":
+		return prefix + d.op + suffix
 
 	case "switch":
-		return expnSwitch("", true, suffix)
+		return expnSwitch("", "", true, suffix)
 	case "switchD":
-		return expnSwitch("", false, suffix)
+		return expnSwitch("", "", false, suffix)
 	case "switchS":
-		return expnSwitch("anyDType", false, suffix)
+		return expnSwitch("", "anyDType", false, suffix)
 
 	case "preOuter":
 		switch d.dType {
@@ -568,7 +581,19 @@
 	return ""
 }
 
-func expnSwitch(dType string, expandBoth bool, template string) string {
+func expnSwitch(op, dType string, expandBoth bool, template string) string {
+	if op == "" && dType != "anyDType" {
+		lines := []string{"switch opts.op() {"}
+		for _, op = range ops {
+			lines = append(lines,
+				fmt.Sprintf("case %s:", op),
+				expnSwitch(op, dType, expandBoth, template),
+			)
+		}
+		lines = append(lines, "}")
+		return strings.Join(lines, "\n")
+	}
+
 	switchVar := "dst"
 	if dType != "" {
 		switchVar = "src"
@@ -588,14 +613,14 @@
 
 		if dType != "" {
 			if v == "*image.YCbCr" {
-				lines = append(lines, expnSwitchYCbCr(dType, template))
+				lines = append(lines, expnSwitchYCbCr(op, dType, template))
 			} else {
-				lines = append(lines, expnLine(template, &data{dType: dType, sType: v}))
+				lines = append(lines, expnLine(template, &data{dType: dType, sType: v, op: op}))
 			}
 		} else if !expandBoth {
-			lines = append(lines, expnLine(template, &data{dType: v}))
+			lines = append(lines, expnLine(template, &data{dType: v, op: op}))
 		} else {
-			lines = append(lines, expnSwitch(v, false, template))
+			lines = append(lines, expnSwitch(op, v, false, template))
 		}
 	}
 
@@ -603,16 +628,16 @@
 	return strings.Join(lines, "\n")
 }
 
-func expnSwitchYCbCr(dType, template string) string {
+func expnSwitchYCbCr(op, dType, template string) string {
 	lines := []string{
 		"switch src.SubsampleRatio {",
 		"default:",
-		expnLine(template, &data{dType: dType, sType: "image.Image"}),
+		expnLine(template, &data{dType: dType, sType: "image.Image", op: op}),
 	}
 	for _, sratio := range subsampleRatios {
 		lines = append(lines,
 			fmt.Sprintf("case image.YCbCrSubsampleRatio%s:", sratio),
-			expnLine(template, &data{dType: dType, sType: "*image.YCbCr", sratio: sratio}),
+			expnLine(template, &data{dType: dType, sType: "*image.YCbCr", sratio: sratio, op: op}),
 		)
 	}
 	lines = append(lines, "}")
@@ -722,12 +747,16 @@
 			// we cannot use the type-specific fast paths, as they access
 			// the Pix fields directly without bounds checking.
 			if !sr.In(src.Bounds()) {
-				z.scale_Image_Image(dst, dr, adr, src, sr)
+				switch opts.op() {
+				case Over:
+					// TODO: z.scale_Image_Image_Over(dst, dr, adr, src, sr)
+				case Src:
+					z.scale_Image_Image_Src(dst, dr, adr, src, sr)
+				}
 			} else if _, ok := src.(*image.Uniform); ok {
-				// TODO: get the Op from opts.
-				Draw(dst, dr, src, src.Bounds().Min, Src)
+				Draw(dst, dr, src, src.Bounds().Min, opts.op())
 			} else {
-				$switch z.scale_$dTypeRN_$sTypeRN$sratio(dst, dr, adr, src, sr)
+				$switch z.scale_$dTypeRN_$sTypeRN$sratio_$op(dst, dr, adr, src, sr)
 			}
 		}
 
@@ -757,18 +786,22 @@
 			// we cannot use the type-specific fast paths, as they access
 			// the Pix fields directly without bounds checking.
 			if !sr.In(src.Bounds()) {
-				z.transform_Image_Image(dst, dr, adr, &d2s, src, sr, bias)
+				switch opts.op() {
+				case Over:
+					// TODO: z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias)
+				case Src:
+					z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias)
+				}
 			} else if u, ok := src.(*image.Uniform); ok {
-				// TODO: get the Op from opts.
-				transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, Src)
+				transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, opts.op())
 			} else {
-				$switch z.transform_$dTypeRN_$sTypeRN$sratio(dst, dr, adr, &d2s, src, sr, bias)
+				$switch z.transform_$dTypeRN_$sTypeRN$sratio_$op(dst, dr, adr, &d2s, src, sr, bias)
 			}
 		}
 	`
 
 	codeNNScaleLeaf = `
-		func (nnInterpolator) scale_$dTypeRN_$sTypeRN$sratio(dst $dType, dr, adr image.Rectangle, src $sType, sr image.Rectangle) {
+		func (nnInterpolator) scale_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, src $sType, sr image.Rectangle) {
 			dw2 := uint64(dr.Dx()) * 2
 			dh2 := uint64(dr.Dy()) * 2
 			sw := uint64(sr.Dx())
@@ -787,7 +820,7 @@
 	`
 
 	codeNNTransformLeaf = `
-		func (nnInterpolator) transform_$dTypeRN_$sTypeRN$sratio(dst $dType, dr, adr image.Rectangle, d2s *f64.Aff3, src $sType, sr image.Rectangle, bias image.Point) {
+		func (nnInterpolator) transform_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, d2s *f64.Aff3, src $sType, sr image.Rectangle, bias image.Point) {
 			$preOuter
 			for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 				dyf := float64(dr.Min.Y + int(dy)) + 0.5
@@ -807,7 +840,7 @@
 	`
 
 	codeABLScaleLeaf = `
-		func (ablInterpolator) scale_$dTypeRN_$sTypeRN$sratio(dst $dType, dr, adr image.Rectangle, src $sType, sr image.Rectangle) {
+		func (ablInterpolator) scale_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, src $sType, sr image.Rectangle) {
 			sw := int32(sr.Dx())
 			sh := int32(sr.Dy())
 			yscale := float64(sh) / float64(dr.Dy())
@@ -861,7 +894,7 @@
 	`
 
 	codeABLTransformLeaf = `
-		func (ablInterpolator) transform_$dTypeRN_$sTypeRN$sratio(dst $dType, dr, adr image.Rectangle, d2s *f64.Aff3, src $sType, sr image.Rectangle, bias image.Point) {
+		func (ablInterpolator) transform_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, d2s *f64.Aff3, src $sType, sr image.Rectangle, bias image.Point) {
 			$preOuter
 			for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 				dyf := float64(dr.Min.Y + int(dy)) + 0.5
@@ -928,8 +961,7 @@
 			}
 
 			if _, ok := src.(*image.Uniform); ok && sr.In(src.Bounds()) {
-				// TODO: get the Op from opts.
-				Draw(dst, dr, src, src.Bounds().Min, Src)
+				Draw(dst, dr, src, src.Bounds().Min, opts.op())
 				return
 			}
 
@@ -954,7 +986,7 @@
 				$switchS z.scaleX_$sTypeRN$sratio(tmp, src, sr)
 			}
 
-			$switchD z.scaleY_$dTypeRN(dst, dr, adr, tmp)
+			$switchD z.scaleY_$dTypeRN_$op(dst, dr, adr, tmp)
 		}
 
 		func (q *Kernel) Transform(dst Image, s2d *f64.Aff3, src image.Image, sr image.Rectangle, opts *Options) {
@@ -981,8 +1013,7 @@
 			adr = adr.Sub(dr.Min)
 
 			if u, ok := src.(*image.Uniform); ok && sr.In(src.Bounds()) {
-				// TODO: get the Op from opts.
-				transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, Src)
+				transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, opts.op())
 				return
 			}
 
@@ -999,9 +1030,14 @@
 			// we cannot use the type-specific fast paths, as they access
 			// the Pix fields directly without bounds checking.
 			if !sr.In(src.Bounds()) {
-				q.transform_Image_Image(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+				switch opts.op() {
+				case Over:
+					// TODO: q.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+				case Src:
+					q.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+				}
 			} else {
-				$switch q.transform_$dTypeRN_$sTypeRN$sratio(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+				$switch q.transform_$dTypeRN_$sTypeRN$sratio_$op(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
 			}
 		}
 	`
@@ -1029,7 +1065,7 @@
 	`
 
 	codeKernelScaleLeafY = `
-		func (z *kernelScaler) scaleY_$dTypeRN(dst $dType, dr, adr image.Rectangle, tmp [][4]float64) {
+		func (z *kernelScaler) scaleY_$dTypeRN_$op(dst $dType, dr, adr image.Rectangle, tmp [][4]float64) {
 			$preOuter
 			for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 				$preKernelInner
@@ -1050,7 +1086,7 @@
 	`
 
 	codeKernelTransformLeaf = `
-		func (q *Kernel) transform_$dTypeRN_$sTypeRN$sratio(dst $dType, dr, adr image.Rectangle, d2s *f64.Aff3, src $sType, sr image.Rectangle, bias image.Point, xscale, yscale float64) {
+		func (q *Kernel) transform_$dTypeRN_$sTypeRN$sratio_$op(dst $dType, dr, adr image.Rectangle, d2s *f64.Aff3, src $sType, sr image.Rectangle, bias image.Point, xscale, yscale float64) {
 			// When shrinking, broaden the effective kernel support so that we still
 			// visit every source pixel.
 			xHalfWidth, xKernelArgScale := q.Support, 1.0
diff --git a/draw/impl.go b/draw/impl.go
index a1de1cd..5f48157 100644
--- a/draw/impl.go
+++ b/draw/impl.go
@@ -20,40 +20,47 @@
 	// we cannot use the type-specific fast paths, as they access
 	// the Pix fields directly without bounds checking.
 	if !sr.In(src.Bounds()) {
-		z.scale_Image_Image(dst, dr, adr, src, sr)
+		switch opts.op() {
+		case Over:
+			// TODO: z.scale_Image_Image_Over(dst, dr, adr, src, sr)
+		case Src:
+			z.scale_Image_Image_Src(dst, dr, adr, src, sr)
+		}
 	} else if _, ok := src.(*image.Uniform); ok {
-		// TODO: get the Op from opts.
-		Draw(dst, dr, src, src.Bounds().Min, Src)
+		Draw(dst, dr, src, src.Bounds().Min, opts.op())
 	} else {
-		switch dst := dst.(type) {
-		case *image.RGBA:
-			switch src := src.(type) {
-			case *image.Gray:
-				z.scale_RGBA_Gray(dst, dr, adr, src, sr)
-			case *image.NRGBA:
-				z.scale_RGBA_NRGBA(dst, dr, adr, src, sr)
+		switch opts.op() {
+		case Src:
+			switch dst := dst.(type) {
 			case *image.RGBA:
-				z.scale_RGBA_RGBA(dst, dr, adr, src, sr)
-			case *image.YCbCr:
-				switch src.SubsampleRatio {
+				switch src := src.(type) {
+				case *image.Gray:
+					z.scale_RGBA_Gray_Src(dst, dr, adr, src, sr)
+				case *image.NRGBA:
+					z.scale_RGBA_NRGBA_Src(dst, dr, adr, src, sr)
+				case *image.RGBA:
+					z.scale_RGBA_RGBA_Src(dst, dr, adr, src, sr)
+				case *image.YCbCr:
+					switch src.SubsampleRatio {
+					default:
+						z.scale_RGBA_Image_Src(dst, dr, adr, src, sr)
+					case image.YCbCrSubsampleRatio444:
+						z.scale_RGBA_YCbCr444_Src(dst, dr, adr, src, sr)
+					case image.YCbCrSubsampleRatio422:
+						z.scale_RGBA_YCbCr422_Src(dst, dr, adr, src, sr)
+					case image.YCbCrSubsampleRatio420:
+						z.scale_RGBA_YCbCr420_Src(dst, dr, adr, src, sr)
+					case image.YCbCrSubsampleRatio440:
+						z.scale_RGBA_YCbCr440_Src(dst, dr, adr, src, sr)
+					}
 				default:
-					z.scale_RGBA_Image(dst, dr, adr, src, sr)
-				case image.YCbCrSubsampleRatio444:
-					z.scale_RGBA_YCbCr444(dst, dr, adr, src, sr)
-				case image.YCbCrSubsampleRatio422:
-					z.scale_RGBA_YCbCr422(dst, dr, adr, src, sr)
-				case image.YCbCrSubsampleRatio420:
-					z.scale_RGBA_YCbCr420(dst, dr, adr, src, sr)
-				case image.YCbCrSubsampleRatio440:
-					z.scale_RGBA_YCbCr440(dst, dr, adr, src, sr)
+					z.scale_RGBA_Image_Src(dst, dr, adr, src, sr)
 				}
 			default:
-				z.scale_RGBA_Image(dst, dr, adr, src, sr)
-			}
-		default:
-			switch src := src.(type) {
-			default:
-				z.scale_Image_Image(dst, dr, adr, src, sr)
+				switch src := src.(type) {
+				default:
+					z.scale_Image_Image_Src(dst, dr, adr, src, sr)
+				}
 			}
 		}
 	}
@@ -85,46 +92,53 @@
 	// we cannot use the type-specific fast paths, as they access
 	// the Pix fields directly without bounds checking.
 	if !sr.In(src.Bounds()) {
-		z.transform_Image_Image(dst, dr, adr, &d2s, src, sr, bias)
+		switch opts.op() {
+		case Over:
+			// TODO: z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias)
+		case Src:
+			z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias)
+		}
 	} else if u, ok := src.(*image.Uniform); ok {
-		// TODO: get the Op from opts.
-		transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, Src)
+		transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, opts.op())
 	} else {
-		switch dst := dst.(type) {
-		case *image.RGBA:
-			switch src := src.(type) {
-			case *image.Gray:
-				z.transform_RGBA_Gray(dst, dr, adr, &d2s, src, sr, bias)
-			case *image.NRGBA:
-				z.transform_RGBA_NRGBA(dst, dr, adr, &d2s, src, sr, bias)
+		switch opts.op() {
+		case Src:
+			switch dst := dst.(type) {
 			case *image.RGBA:
-				z.transform_RGBA_RGBA(dst, dr, adr, &d2s, src, sr, bias)
-			case *image.YCbCr:
-				switch src.SubsampleRatio {
+				switch src := src.(type) {
+				case *image.Gray:
+					z.transform_RGBA_Gray_Src(dst, dr, adr, &d2s, src, sr, bias)
+				case *image.NRGBA:
+					z.transform_RGBA_NRGBA_Src(dst, dr, adr, &d2s, src, sr, bias)
+				case *image.RGBA:
+					z.transform_RGBA_RGBA_Src(dst, dr, adr, &d2s, src, sr, bias)
+				case *image.YCbCr:
+					switch src.SubsampleRatio {
+					default:
+						z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias)
+					case image.YCbCrSubsampleRatio444:
+						z.transform_RGBA_YCbCr444_Src(dst, dr, adr, &d2s, src, sr, bias)
+					case image.YCbCrSubsampleRatio422:
+						z.transform_RGBA_YCbCr422_Src(dst, dr, adr, &d2s, src, sr, bias)
+					case image.YCbCrSubsampleRatio420:
+						z.transform_RGBA_YCbCr420_Src(dst, dr, adr, &d2s, src, sr, bias)
+					case image.YCbCrSubsampleRatio440:
+						z.transform_RGBA_YCbCr440_Src(dst, dr, adr, &d2s, src, sr, bias)
+					}
 				default:
-					z.transform_RGBA_Image(dst, dr, adr, &d2s, src, sr, bias)
-				case image.YCbCrSubsampleRatio444:
-					z.transform_RGBA_YCbCr444(dst, dr, adr, &d2s, src, sr, bias)
-				case image.YCbCrSubsampleRatio422:
-					z.transform_RGBA_YCbCr422(dst, dr, adr, &d2s, src, sr, bias)
-				case image.YCbCrSubsampleRatio420:
-					z.transform_RGBA_YCbCr420(dst, dr, adr, &d2s, src, sr, bias)
-				case image.YCbCrSubsampleRatio440:
-					z.transform_RGBA_YCbCr440(dst, dr, adr, &d2s, src, sr, bias)
+					z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias)
 				}
 			default:
-				z.transform_RGBA_Image(dst, dr, adr, &d2s, src, sr, bias)
-			}
-		default:
-			switch src := src.(type) {
-			default:
-				z.transform_Image_Image(dst, dr, adr, &d2s, src, sr, bias)
+				switch src := src.(type) {
+				default:
+					z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias)
+				}
 			}
 		}
 	}
 }
 
-func (nnInterpolator) scale_RGBA_Gray(dst *image.RGBA, dr, adr image.Rectangle, src *image.Gray, sr image.Rectangle) {
+func (nnInterpolator) scale_RGBA_Gray_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.Gray, sr image.Rectangle) {
 	dw2 := uint64(dr.Dx()) * 2
 	dh2 := uint64(dr.Dy()) * 2
 	sw := uint64(sr.Dx())
@@ -145,7 +159,7 @@
 	}
 }
 
-func (nnInterpolator) scale_RGBA_NRGBA(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle) {
+func (nnInterpolator) scale_RGBA_NRGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle) {
 	dw2 := uint64(dr.Dx()) * 2
 	dh2 := uint64(dr.Dy()) * 2
 	sw := uint64(sr.Dx())
@@ -168,7 +182,7 @@
 	}
 }
 
-func (nnInterpolator) scale_RGBA_RGBA(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle) {
+func (nnInterpolator) scale_RGBA_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle) {
 	dw2 := uint64(dr.Dx()) * 2
 	dh2 := uint64(dr.Dy()) * 2
 	sw := uint64(sr.Dx())
@@ -191,7 +205,7 @@
 	}
 }
 
-func (nnInterpolator) scale_RGBA_YCbCr444(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
+func (nnInterpolator) scale_RGBA_YCbCr444_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
 	dw2 := uint64(dr.Dx()) * 2
 	dh2 := uint64(dr.Dy()) * 2
 	sw := uint64(sr.Dx())
@@ -234,7 +248,7 @@
 	}
 }
 
-func (nnInterpolator) scale_RGBA_YCbCr422(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
+func (nnInterpolator) scale_RGBA_YCbCr422_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
 	dw2 := uint64(dr.Dx()) * 2
 	dh2 := uint64(dr.Dy()) * 2
 	sw := uint64(sr.Dx())
@@ -277,7 +291,7 @@
 	}
 }
 
-func (nnInterpolator) scale_RGBA_YCbCr420(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
+func (nnInterpolator) scale_RGBA_YCbCr420_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
 	dw2 := uint64(dr.Dx()) * 2
 	dh2 := uint64(dr.Dy()) * 2
 	sw := uint64(sr.Dx())
@@ -320,7 +334,7 @@
 	}
 }
 
-func (nnInterpolator) scale_RGBA_YCbCr440(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
+func (nnInterpolator) scale_RGBA_YCbCr440_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
 	dw2 := uint64(dr.Dx()) * 2
 	dh2 := uint64(dr.Dy()) * 2
 	sw := uint64(sr.Dx())
@@ -363,7 +377,7 @@
 	}
 }
 
-func (nnInterpolator) scale_RGBA_Image(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle) {
+func (nnInterpolator) scale_RGBA_Image_Src(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle) {
 	dw2 := uint64(dr.Dx()) * 2
 	dh2 := uint64(dr.Dy()) * 2
 	sw := uint64(sr.Dx())
@@ -382,7 +396,7 @@
 	}
 }
 
-func (nnInterpolator) scale_Image_Image(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle) {
+func (nnInterpolator) scale_Image_Image_Src(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle) {
 	dw2 := uint64(dr.Dx()) * 2
 	dh2 := uint64(dr.Dy()) * 2
 	sw := uint64(sr.Dx())
@@ -403,7 +417,7 @@
 	}
 }
 
-func (nnInterpolator) transform_RGBA_Gray(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Gray, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -425,7 +439,7 @@
 	}
 }
 
-func (nnInterpolator) transform_RGBA_NRGBA(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -449,7 +463,7 @@
 	}
 }
 
-func (nnInterpolator) transform_RGBA_RGBA(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -473,7 +487,7 @@
 	}
 }
 
-func (nnInterpolator) transform_RGBA_YCbCr444(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -517,7 +531,7 @@
 	}
 }
 
-func (nnInterpolator) transform_RGBA_YCbCr422(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -561,7 +575,7 @@
 	}
 }
 
-func (nnInterpolator) transform_RGBA_YCbCr420(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -605,7 +619,7 @@
 	}
 }
 
-func (nnInterpolator) transform_RGBA_YCbCr440(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -649,7 +663,7 @@
 	}
 }
 
-func (nnInterpolator) transform_RGBA_Image(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -669,7 +683,7 @@
 	}
 }
 
-func (nnInterpolator) transform_Image_Image(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point) {
+func (nnInterpolator) transform_Image_Image_Src(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point) {
 	dstColorRGBA64 := &color.RGBA64{}
 	dstColor := color.Color(dstColorRGBA64)
 	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
@@ -701,40 +715,47 @@
 	// we cannot use the type-specific fast paths, as they access
 	// the Pix fields directly without bounds checking.
 	if !sr.In(src.Bounds()) {
-		z.scale_Image_Image(dst, dr, adr, src, sr)
+		switch opts.op() {
+		case Over:
+			// TODO: z.scale_Image_Image_Over(dst, dr, adr, src, sr)
+		case Src:
+			z.scale_Image_Image_Src(dst, dr, adr, src, sr)
+		}
 	} else if _, ok := src.(*image.Uniform); ok {
-		// TODO: get the Op from opts.
-		Draw(dst, dr, src, src.Bounds().Min, Src)
+		Draw(dst, dr, src, src.Bounds().Min, opts.op())
 	} else {
-		switch dst := dst.(type) {
-		case *image.RGBA:
-			switch src := src.(type) {
-			case *image.Gray:
-				z.scale_RGBA_Gray(dst, dr, adr, src, sr)
-			case *image.NRGBA:
-				z.scale_RGBA_NRGBA(dst, dr, adr, src, sr)
+		switch opts.op() {
+		case Src:
+			switch dst := dst.(type) {
 			case *image.RGBA:
-				z.scale_RGBA_RGBA(dst, dr, adr, src, sr)
-			case *image.YCbCr:
-				switch src.SubsampleRatio {
+				switch src := src.(type) {
+				case *image.Gray:
+					z.scale_RGBA_Gray_Src(dst, dr, adr, src, sr)
+				case *image.NRGBA:
+					z.scale_RGBA_NRGBA_Src(dst, dr, adr, src, sr)
+				case *image.RGBA:
+					z.scale_RGBA_RGBA_Src(dst, dr, adr, src, sr)
+				case *image.YCbCr:
+					switch src.SubsampleRatio {
+					default:
+						z.scale_RGBA_Image_Src(dst, dr, adr, src, sr)
+					case image.YCbCrSubsampleRatio444:
+						z.scale_RGBA_YCbCr444_Src(dst, dr, adr, src, sr)
+					case image.YCbCrSubsampleRatio422:
+						z.scale_RGBA_YCbCr422_Src(dst, dr, adr, src, sr)
+					case image.YCbCrSubsampleRatio420:
+						z.scale_RGBA_YCbCr420_Src(dst, dr, adr, src, sr)
+					case image.YCbCrSubsampleRatio440:
+						z.scale_RGBA_YCbCr440_Src(dst, dr, adr, src, sr)
+					}
 				default:
-					z.scale_RGBA_Image(dst, dr, adr, src, sr)
-				case image.YCbCrSubsampleRatio444:
-					z.scale_RGBA_YCbCr444(dst, dr, adr, src, sr)
-				case image.YCbCrSubsampleRatio422:
-					z.scale_RGBA_YCbCr422(dst, dr, adr, src, sr)
-				case image.YCbCrSubsampleRatio420:
-					z.scale_RGBA_YCbCr420(dst, dr, adr, src, sr)
-				case image.YCbCrSubsampleRatio440:
-					z.scale_RGBA_YCbCr440(dst, dr, adr, src, sr)
+					z.scale_RGBA_Image_Src(dst, dr, adr, src, sr)
 				}
 			default:
-				z.scale_RGBA_Image(dst, dr, adr, src, sr)
-			}
-		default:
-			switch src := src.(type) {
-			default:
-				z.scale_Image_Image(dst, dr, adr, src, sr)
+				switch src := src.(type) {
+				default:
+					z.scale_Image_Image_Src(dst, dr, adr, src, sr)
+				}
 			}
 		}
 	}
@@ -766,46 +787,53 @@
 	// we cannot use the type-specific fast paths, as they access
 	// the Pix fields directly without bounds checking.
 	if !sr.In(src.Bounds()) {
-		z.transform_Image_Image(dst, dr, adr, &d2s, src, sr, bias)
+		switch opts.op() {
+		case Over:
+			// TODO: z.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias)
+		case Src:
+			z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias)
+		}
 	} else if u, ok := src.(*image.Uniform); ok {
-		// TODO: get the Op from opts.
-		transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, Src)
+		transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, opts.op())
 	} else {
-		switch dst := dst.(type) {
-		case *image.RGBA:
-			switch src := src.(type) {
-			case *image.Gray:
-				z.transform_RGBA_Gray(dst, dr, adr, &d2s, src, sr, bias)
-			case *image.NRGBA:
-				z.transform_RGBA_NRGBA(dst, dr, adr, &d2s, src, sr, bias)
+		switch opts.op() {
+		case Src:
+			switch dst := dst.(type) {
 			case *image.RGBA:
-				z.transform_RGBA_RGBA(dst, dr, adr, &d2s, src, sr, bias)
-			case *image.YCbCr:
-				switch src.SubsampleRatio {
+				switch src := src.(type) {
+				case *image.Gray:
+					z.transform_RGBA_Gray_Src(dst, dr, adr, &d2s, src, sr, bias)
+				case *image.NRGBA:
+					z.transform_RGBA_NRGBA_Src(dst, dr, adr, &d2s, src, sr, bias)
+				case *image.RGBA:
+					z.transform_RGBA_RGBA_Src(dst, dr, adr, &d2s, src, sr, bias)
+				case *image.YCbCr:
+					switch src.SubsampleRatio {
+					default:
+						z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias)
+					case image.YCbCrSubsampleRatio444:
+						z.transform_RGBA_YCbCr444_Src(dst, dr, adr, &d2s, src, sr, bias)
+					case image.YCbCrSubsampleRatio422:
+						z.transform_RGBA_YCbCr422_Src(dst, dr, adr, &d2s, src, sr, bias)
+					case image.YCbCrSubsampleRatio420:
+						z.transform_RGBA_YCbCr420_Src(dst, dr, adr, &d2s, src, sr, bias)
+					case image.YCbCrSubsampleRatio440:
+						z.transform_RGBA_YCbCr440_Src(dst, dr, adr, &d2s, src, sr, bias)
+					}
 				default:
-					z.transform_RGBA_Image(dst, dr, adr, &d2s, src, sr, bias)
-				case image.YCbCrSubsampleRatio444:
-					z.transform_RGBA_YCbCr444(dst, dr, adr, &d2s, src, sr, bias)
-				case image.YCbCrSubsampleRatio422:
-					z.transform_RGBA_YCbCr422(dst, dr, adr, &d2s, src, sr, bias)
-				case image.YCbCrSubsampleRatio420:
-					z.transform_RGBA_YCbCr420(dst, dr, adr, &d2s, src, sr, bias)
-				case image.YCbCrSubsampleRatio440:
-					z.transform_RGBA_YCbCr440(dst, dr, adr, &d2s, src, sr, bias)
+					z.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias)
 				}
 			default:
-				z.transform_RGBA_Image(dst, dr, adr, &d2s, src, sr, bias)
-			}
-		default:
-			switch src := src.(type) {
-			default:
-				z.transform_Image_Image(dst, dr, adr, &d2s, src, sr, bias)
+				switch src := src.(type) {
+				default:
+					z.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias)
+				}
 			}
 		}
 	}
 }
 
-func (ablInterpolator) scale_RGBA_Gray(dst *image.RGBA, dr, adr image.Rectangle, src *image.Gray, sr image.Rectangle) {
+func (ablInterpolator) scale_RGBA_Gray_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.Gray, sr image.Rectangle) {
 	sw := int32(sr.Dx())
 	sh := int32(sr.Dy())
 	yscale := float64(sh) / float64(dr.Dy())
@@ -868,7 +896,7 @@
 	}
 }
 
-func (ablInterpolator) scale_RGBA_NRGBA(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle) {
+func (ablInterpolator) scale_RGBA_NRGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.NRGBA, sr image.Rectangle) {
 	sw := int32(sr.Dx())
 	sh := int32(sr.Dy())
 	yscale := float64(sh) / float64(dr.Dy())
@@ -963,7 +991,7 @@
 	}
 }
 
-func (ablInterpolator) scale_RGBA_RGBA(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle) {
+func (ablInterpolator) scale_RGBA_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.RGBA, sr image.Rectangle) {
 	sw := int32(sr.Dx())
 	sh := int32(sr.Dy())
 	yscale := float64(sh) / float64(dr.Dy())
@@ -1058,7 +1086,7 @@
 	}
 }
 
-func (ablInterpolator) scale_RGBA_YCbCr444(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
+func (ablInterpolator) scale_RGBA_YCbCr444_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
 	sw := int32(sr.Dx())
 	sh := int32(sr.Dy())
 	yscale := float64(sh) / float64(dr.Dy())
@@ -1230,7 +1258,7 @@
 	}
 }
 
-func (ablInterpolator) scale_RGBA_YCbCr422(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
+func (ablInterpolator) scale_RGBA_YCbCr422_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
 	sw := int32(sr.Dx())
 	sh := int32(sr.Dy())
 	yscale := float64(sh) / float64(dr.Dy())
@@ -1402,7 +1430,7 @@
 	}
 }
 
-func (ablInterpolator) scale_RGBA_YCbCr420(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
+func (ablInterpolator) scale_RGBA_YCbCr420_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
 	sw := int32(sr.Dx())
 	sh := int32(sr.Dy())
 	yscale := float64(sh) / float64(dr.Dy())
@@ -1574,7 +1602,7 @@
 	}
 }
 
-func (ablInterpolator) scale_RGBA_YCbCr440(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
+func (ablInterpolator) scale_RGBA_YCbCr440_Src(dst *image.RGBA, dr, adr image.Rectangle, src *image.YCbCr, sr image.Rectangle) {
 	sw := int32(sr.Dx())
 	sh := int32(sr.Dy())
 	yscale := float64(sh) / float64(dr.Dy())
@@ -1746,7 +1774,7 @@
 	}
 }
 
-func (ablInterpolator) scale_RGBA_Image(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle) {
+func (ablInterpolator) scale_RGBA_Image_Src(dst *image.RGBA, dr, adr image.Rectangle, src image.Image, sr image.Rectangle) {
 	sw := int32(sr.Dx())
 	sh := int32(sr.Dy())
 	yscale := float64(sh) / float64(dr.Dy())
@@ -1825,7 +1853,7 @@
 	}
 }
 
-func (ablInterpolator) scale_Image_Image(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle) {
+func (ablInterpolator) scale_Image_Image_Src(dst Image, dr, adr image.Rectangle, src image.Image, sr image.Rectangle) {
 	sw := int32(sr.Dx())
 	sh := int32(sr.Dy())
 	yscale := float64(sh) / float64(dr.Dy())
@@ -1906,7 +1934,7 @@
 	}
 }
 
-func (ablInterpolator) transform_RGBA_Gray(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Gray, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -1970,7 +1998,7 @@
 	}
 }
 
-func (ablInterpolator) transform_RGBA_NRGBA(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -2066,7 +2094,7 @@
 	}
 }
 
-func (ablInterpolator) transform_RGBA_RGBA(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -2162,7 +2190,7 @@
 	}
 }
 
-func (ablInterpolator) transform_RGBA_YCbCr444(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -2335,7 +2363,7 @@
 	}
 }
 
-func (ablInterpolator) transform_RGBA_YCbCr422(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -2508,7 +2536,7 @@
 	}
 }
 
-func (ablInterpolator) transform_RGBA_YCbCr420(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -2681,7 +2709,7 @@
 	}
 }
 
-func (ablInterpolator) transform_RGBA_YCbCr440(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -2854,7 +2882,7 @@
 	}
 }
 
-func (ablInterpolator) transform_RGBA_Image(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point) {
+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) {
 	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
@@ -2934,7 +2962,7 @@
 	}
 }
 
-func (ablInterpolator) transform_Image_Image(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point) {
+func (ablInterpolator) transform_Image_Image_Src(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point) {
 	dstColorRGBA64 := &color.RGBA64{}
 	dstColor := color.Color(dstColorRGBA64)
 	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
@@ -3028,8 +3056,7 @@
 	}
 
 	if _, ok := src.(*image.Uniform); ok && sr.In(src.Bounds()) {
-		// TODO: get the Op from opts.
-		Draw(dst, dr, src, src.Bounds().Min, Src)
+		Draw(dst, dr, src, src.Bounds().Min, opts.op())
 		return
 	}
 
@@ -3076,11 +3103,14 @@
 		}
 	}
 
-	switch dst := dst.(type) {
-	case *image.RGBA:
-		z.scaleY_RGBA(dst, dr, adr, tmp)
-	default:
-		z.scaleY_Image(dst, dr, adr, tmp)
+	switch opts.op() {
+	case Src:
+		switch dst := dst.(type) {
+		case *image.RGBA:
+			z.scaleY_RGBA_Src(dst, dr, adr, tmp)
+		default:
+			z.scaleY_Image_Src(dst, dr, adr, tmp)
+		}
 	}
 }
 
@@ -3108,8 +3138,7 @@
 	adr = adr.Sub(dr.Min)
 
 	if u, ok := src.(*image.Uniform); ok && sr.In(src.Bounds()) {
-		// TODO: get the Op from opts.
-		transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, Src)
+		transform_Uniform(dst, dr, adr, &d2s, u, sr, bias, opts.op())
 		return
 	}
 
@@ -3126,37 +3155,45 @@
 	// we cannot use the type-specific fast paths, as they access
 	// the Pix fields directly without bounds checking.
 	if !sr.In(src.Bounds()) {
-		q.transform_Image_Image(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+		switch opts.op() {
+		case Over:
+			// TODO: q.transform_Image_Image_Over(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+		case Src:
+			q.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+		}
 	} else {
-		switch dst := dst.(type) {
-		case *image.RGBA:
-			switch src := src.(type) {
-			case *image.Gray:
-				q.transform_RGBA_Gray(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
-			case *image.NRGBA:
-				q.transform_RGBA_NRGBA(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+		switch opts.op() {
+		case Src:
+			switch dst := dst.(type) {
 			case *image.RGBA:
-				q.transform_RGBA_RGBA(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
-			case *image.YCbCr:
-				switch src.SubsampleRatio {
+				switch src := src.(type) {
+				case *image.Gray:
+					q.transform_RGBA_Gray_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+				case *image.NRGBA:
+					q.transform_RGBA_NRGBA_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+				case *image.RGBA:
+					q.transform_RGBA_RGBA_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+				case *image.YCbCr:
+					switch src.SubsampleRatio {
+					default:
+						q.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+					case image.YCbCrSubsampleRatio444:
+						q.transform_RGBA_YCbCr444_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+					case image.YCbCrSubsampleRatio422:
+						q.transform_RGBA_YCbCr422_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+					case image.YCbCrSubsampleRatio420:
+						q.transform_RGBA_YCbCr420_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+					case image.YCbCrSubsampleRatio440:
+						q.transform_RGBA_YCbCr440_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+					}
 				default:
-					q.transform_RGBA_Image(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
-				case image.YCbCrSubsampleRatio444:
-					q.transform_RGBA_YCbCr444(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
-				case image.YCbCrSubsampleRatio422:
-					q.transform_RGBA_YCbCr422(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
-				case image.YCbCrSubsampleRatio420:
-					q.transform_RGBA_YCbCr420(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
-				case image.YCbCrSubsampleRatio440:
-					q.transform_RGBA_YCbCr440(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+					q.transform_RGBA_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
 				}
 			default:
-				q.transform_RGBA_Image(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
-			}
-		default:
-			switch src := src.(type) {
-			default:
-				q.transform_Image_Image(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+				switch src := src.(type) {
+				default:
+					q.transform_Image_Image_Src(dst, dr, adr, &d2s, src, sr, bias, xscale, yscale)
+				}
 			}
 		}
 	}
@@ -3449,7 +3486,7 @@
 	}
 }
 
-func (z *kernelScaler) scaleY_RGBA(dst *image.RGBA, dr, adr image.Rectangle, tmp [][4]float64) {
+func (z *kernelScaler) scaleY_RGBA_Src(dst *image.RGBA, dr, adr image.Rectangle, tmp [][4]float64) {
 	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] {
@@ -3470,7 +3507,7 @@
 	}
 }
 
-func (z *kernelScaler) scaleY_Image(dst Image, dr, adr image.Rectangle, tmp [][4]float64) {
+func (z *kernelScaler) scaleY_Image_Src(dst Image, dr, adr image.Rectangle, tmp [][4]float64) {
 	dstColorRGBA64 := &color.RGBA64{}
 	dstColor := color.Color(dstColorRGBA64)
 	for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
@@ -3492,7 +3529,7 @@
 	}
 }
 
-func (q *Kernel) transform_RGBA_Gray(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Gray, sr image.Rectangle, bias image.Point, xscale, yscale float64) {
+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) {
 	// When shrinking, broaden the effective kernel support so that we still
 	// visit every source pixel.
 	xHalfWidth, xKernelArgScale := q.Support, 1.0
@@ -3591,7 +3628,7 @@
 	}
 }
 
-func (q *Kernel) transform_RGBA_NRGBA(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.NRGBA, sr image.Rectangle, bias image.Point, xscale, yscale float64) {
+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) {
 	// When shrinking, broaden the effective kernel support so that we still
 	// visit every source pixel.
 	xHalfWidth, xKernelArgScale := q.Support, 1.0
@@ -3695,7 +3732,7 @@
 	}
 }
 
-func (q *Kernel) transform_RGBA_RGBA(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.RGBA, sr image.Rectangle, bias image.Point, xscale, yscale float64) {
+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) {
 	// When shrinking, broaden the effective kernel support so that we still
 	// visit every source pixel.
 	xHalfWidth, xKernelArgScale := q.Support, 1.0
@@ -3799,7 +3836,7 @@
 	}
 }
 
-func (q *Kernel) transform_RGBA_YCbCr444(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, xscale, yscale float64) {
+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) {
 	// When shrinking, broaden the effective kernel support so that we still
 	// visit every source pixel.
 	xHalfWidth, xKernelArgScale := q.Support, 1.0
@@ -3923,7 +3960,7 @@
 	}
 }
 
-func (q *Kernel) transform_RGBA_YCbCr422(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, xscale, yscale float64) {
+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) {
 	// When shrinking, broaden the effective kernel support so that we still
 	// visit every source pixel.
 	xHalfWidth, xKernelArgScale := q.Support, 1.0
@@ -4047,7 +4084,7 @@
 	}
 }
 
-func (q *Kernel) transform_RGBA_YCbCr420(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, xscale, yscale float64) {
+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) {
 	// When shrinking, broaden the effective kernel support so that we still
 	// visit every source pixel.
 	xHalfWidth, xKernelArgScale := q.Support, 1.0
@@ -4171,7 +4208,7 @@
 	}
 }
 
-func (q *Kernel) transform_RGBA_YCbCr440(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.YCbCr, sr image.Rectangle, bias image.Point, xscale, yscale float64) {
+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) {
 	// When shrinking, broaden the effective kernel support so that we still
 	// visit every source pixel.
 	xHalfWidth, xKernelArgScale := q.Support, 1.0
@@ -4295,7 +4332,7 @@
 	}
 }
 
-func (q *Kernel) transform_RGBA_Image(dst *image.RGBA, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, xscale, yscale float64) {
+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) {
 	// When shrinking, broaden the effective kernel support so that we still
 	// visit every source pixel.
 	xHalfWidth, xKernelArgScale := q.Support, 1.0
@@ -4395,7 +4432,7 @@
 	}
 }
 
-func (q *Kernel) transform_Image_Image(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src image.Image, sr image.Rectangle, bias image.Point, xscale, yscale float64) {
+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) {
 	// When shrinking, broaden the effective kernel support so that we still
 	// visit every source pixel.
 	xHalfWidth, xKernelArgScale := q.Support, 1.0
diff --git a/draw/scale.go b/draw/scale.go
index 2e481b1..39520f4 100644
--- a/draw/scale.go
+++ b/draw/scale.go
@@ -19,12 +19,12 @@
 // the part of the destination image defined by dst and the translation of sr
 // so that sr.Min translates to dp.
 func Copy(dst Image, dp image.Point, src image.Image, sr image.Rectangle, opts *Options) {
-	mask, mp, op := image.Image(nil), image.Point{}, Over
+	mask, mp := image.Image(nil), image.Point{}
 	if opts != nil {
-		// TODO: set mask, mp and op.
+		// TODO: set mask and mp.
 	}
 	dr := sr.Add(dp.Sub(sr.Min))
-	DrawMask(dst, dr, src, sr.Min, mask, mp, op)
+	DrawMask(dst, dr, src, sr.Min, mask, mp, opts.op())
 }
 
 // Scaler scales the part of the source image defined by src and sr and writes
@@ -56,10 +56,20 @@
 //
 // A nil *Options means to use the default (zero) values of each field.
 type Options struct {
+	// Op is the compositing operator. The default value is Over.
+	Op Op
+
 	// TODO: add fields a la
 	// https://groups.google.com/forum/#!topic/golang-dev/fgn_xM0aeq4
 }
 
+func (o *Options) op() Op {
+	if o == nil {
+		return Over
+	}
+	return o.Op
+}
+
 // Interpolator is an interpolation algorithm, when dst and src pixels don't
 // have a 1:1 correspondence.
 //
@@ -371,6 +381,7 @@
 }
 
 func transform_Uniform(dst Image, dr, adr image.Rectangle, d2s *f64.Aff3, src *image.Uniform, sr image.Rectangle, bias image.Point, op Op) {
+	// TODO: implement op == Over.
 	switch dst := dst.(type) {
 	case *image.RGBA:
 		pr, pg, pb, pa := src.C.RGBA()
diff --git a/draw/scale_test.go b/draw/scale_test.go
index 9cce5b1..65a536a 100644
--- a/draw/scale_test.go
+++ b/draw/scale_test.go
@@ -59,6 +59,9 @@
 	if err != nil {
 		t.Fatalf("Decode: %v", err)
 	}
+	opts := &Options{
+		Op: Src,
+	}
 	testCases := map[string]Interpolator{
 		"nn": NearestNeighbor,
 		"ab": ApproxBiLinear,
@@ -70,9 +73,9 @@
 
 		got := image.NewRGBA(image.Rect(0, 0, w, h))
 		if direction == "rotate" {
-			q.Transform(got, transformMatrix(40, 10), src, src.Bounds(), nil)
+			q.Transform(got, transformMatrix(40, 10), src, src.Bounds(), opts)
 		} else {
-			q.Scale(got, got.Bounds(), src, src.Bounds(), nil)
+			q.Scale(got, got.Bounds(), src, src.Bounds(), opts)
 		}
 
 		if *genGoldenFiles {
@@ -276,7 +279,7 @@
 		srcGray,
 		srcNRGBA,
 		srcRGBA,
-		srcUniform,
+		srcUnif,
 		srcYCbCr,
 	}
 	var srcs []image.Image
@@ -293,6 +296,9 @@
 		CatmullRom,
 	}
 	blue := image.NewUniform(color.RGBA{0x11, 0x22, 0x44, 0x7f})
+	opts := &Options{
+		Op: Src,
+	}
 
 	for _, dr := range drs {
 		for _, src := range srcs {
@@ -306,11 +312,11 @@
 
 						if transform {
 							m := transformMatrix(2, 1)
-							q.Transform(dst0, m, src, sr, nil)
-							q.Transform(dstWrapper{dst1}, m, srcWrapper{src}, sr, nil)
+							q.Transform(dst0, m, src, sr, opts)
+							q.Transform(dstWrapper{dst1}, m, srcWrapper{src}, sr, opts)
 						} else {
-							q.Scale(dst0, dr, src, sr, nil)
-							q.Scale(dstWrapper{dst1}, dr, srcWrapper{src}, sr, nil)
+							q.Scale(dst0, dr, src, sr, opts)
+							q.Scale(dstWrapper{dst1}, dr, srcWrapper{src}, sr, opts)
 						}
 
 						if !bytes.Equal(dst0.Pix, dst1.Pix) {
@@ -349,7 +355,7 @@
 	return m, nil
 }
 
-func srcUniform(boundsHint image.Rectangle) (image.Image, error) {
+func srcUnif(boundsHint image.Rectangle) (image.Image, error) {
 	return image.NewUniform(color.RGBA64{0x1234, 0x5555, 0x9181, 0xbeef}), nil
 }
 
@@ -359,7 +365,7 @@
 	return m, nil
 }
 
-func srcYCbCrLarge(boundsHint image.Rectangle) (image.Image, error) {
+func srcLarge(boundsHint image.Rectangle) (image.Image, error) {
 	// 3072 x 2304 is over 7 million pixels at 4:3, comparable to a
 	// 2015 smart-phone camera's output.
 	return srcYCbCr(image.Rect(0, 0, 3072, 2304))
@@ -379,7 +385,7 @@
 	return src, nil
 }
 
-func benchScale(b *testing.B, srcf func(image.Rectangle) (image.Image, error), w int, h int, q Interpolator) {
+func benchScale(b *testing.B, w int, h int, op Op, srcf func(image.Rectangle) (image.Image, error), q Interpolator) {
 	dst := image.NewRGBA(image.Rect(0, 0, w, h))
 	src, err := srcf(image.Rect(0, 0, 1024, 768))
 	if err != nil {
@@ -392,15 +398,18 @@
 	}); ok {
 		scaler = n.NewScaler(dr.Dx(), dr.Dy(), sr.Dx(), sr.Dy())
 	}
+	opts := &Options{
+		Op: op,
+	}
 
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		scaler.Scale(dst, dr, src, sr, nil)
+		scaler.Scale(dst, dr, src, sr, opts)
 	}
 }
 
-func benchTform(b *testing.B, srcf func(image.Rectangle) (image.Image, error), w int, h int, q Interpolator) {
+func benchTform(b *testing.B, w int, h int, op Op, srcf func(image.Rectangle) (image.Image, error), q Interpolator) {
 	dst := image.NewRGBA(image.Rect(0, 0, w, h))
 	src, err := srcf(image.Rect(0, 0, 1024, 768))
 	if err != nil {
@@ -408,51 +417,54 @@
 	}
 	sr := src.Bounds()
 	m := transformMatrix(40, 10)
+	opts := &Options{
+		Op: op,
+	}
 
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		q.Transform(dst, m, src, sr, nil)
+		q.Transform(dst, m, src, sr, opts)
 	}
 }
 
-func BenchmarkScaleNNLargeDown(b *testing.B) { benchScale(b, srcYCbCrLarge, 200, 150, NearestNeighbor) }
-func BenchmarkScaleABLargeDown(b *testing.B) { benchScale(b, srcYCbCrLarge, 200, 150, ApproxBiLinear) }
-func BenchmarkScaleBLLargeDown(b *testing.B) { benchScale(b, srcYCbCrLarge, 200, 150, BiLinear) }
-func BenchmarkScaleCRLargeDown(b *testing.B) { benchScale(b, srcYCbCrLarge, 200, 150, CatmullRom) }
+func BenchmarkScaleNNLargeDown(b *testing.B) { benchScale(b, 200, 150, Src, srcLarge, NearestNeighbor) }
+func BenchmarkScaleABLargeDown(b *testing.B) { benchScale(b, 200, 150, Src, srcLarge, ApproxBiLinear) }
+func BenchmarkScaleBLLargeDown(b *testing.B) { benchScale(b, 200, 150, Src, srcLarge, BiLinear) }
+func BenchmarkScaleCRLargeDown(b *testing.B) { benchScale(b, 200, 150, Src, srcLarge, CatmullRom) }
 
-func BenchmarkScaleNNDown(b *testing.B) { benchScale(b, srcTux, 120, 80, NearestNeighbor) }
-func BenchmarkScaleABDown(b *testing.B) { benchScale(b, srcTux, 120, 80, ApproxBiLinear) }
-func BenchmarkScaleBLDown(b *testing.B) { benchScale(b, srcTux, 120, 80, BiLinear) }
-func BenchmarkScaleCRDown(b *testing.B) { benchScale(b, srcTux, 120, 80, CatmullRom) }
+func BenchmarkScaleNNDown(b *testing.B) { benchScale(b, 120, 80, Src, srcTux, NearestNeighbor) }
+func BenchmarkScaleABDown(b *testing.B) { benchScale(b, 120, 80, Src, srcTux, ApproxBiLinear) }
+func BenchmarkScaleBLDown(b *testing.B) { benchScale(b, 120, 80, Src, srcTux, BiLinear) }
+func BenchmarkScaleCRDown(b *testing.B) { benchScale(b, 120, 80, Src, srcTux, CatmullRom) }
 
-func BenchmarkScaleNNUp(b *testing.B) { benchScale(b, srcTux, 800, 600, NearestNeighbor) }
-func BenchmarkScaleABUp(b *testing.B) { benchScale(b, srcTux, 800, 600, ApproxBiLinear) }
-func BenchmarkScaleBLUp(b *testing.B) { benchScale(b, srcTux, 800, 600, BiLinear) }
-func BenchmarkScaleCRUp(b *testing.B) { benchScale(b, srcTux, 800, 600, CatmullRom) }
+func BenchmarkScaleNNUp(b *testing.B) { benchScale(b, 800, 600, Src, srcTux, NearestNeighbor) }
+func BenchmarkScaleABUp(b *testing.B) { benchScale(b, 800, 600, Src, srcTux, ApproxBiLinear) }
+func BenchmarkScaleBLUp(b *testing.B) { benchScale(b, 800, 600, Src, srcTux, BiLinear) }
+func BenchmarkScaleCRUp(b *testing.B) { benchScale(b, 800, 600, Src, srcTux, CatmullRom) }
 
-func BenchmarkScaleNNSrcRGBA(b *testing.B)    { benchScale(b, srcRGBA, 200, 150, NearestNeighbor) }
-func BenchmarkScaleNNSrcUniform(b *testing.B) { benchScale(b, srcUniform, 200, 150, NearestNeighbor) }
+func BenchmarkScaleNNSrcRGBA(b *testing.B)    { benchScale(b, 200, 150, Src, srcRGBA, NearestNeighbor) }
+func BenchmarkScaleNNSrcUniform(b *testing.B) { benchScale(b, 200, 150, Src, srcUnif, NearestNeighbor) }
 
-func BenchmarkTformNNSrcRGBA(b *testing.B)    { benchTform(b, srcRGBA, 200, 150, NearestNeighbor) }
-func BenchmarkTformNNSrcUniform(b *testing.B) { benchTform(b, srcUniform, 200, 150, NearestNeighbor) }
+func BenchmarkTformNNSrcRGBA(b *testing.B)    { benchTform(b, 200, 150, Src, srcRGBA, NearestNeighbor) }
+func BenchmarkTformNNSrcUniform(b *testing.B) { benchTform(b, 200, 150, Src, srcUnif, NearestNeighbor) }
 
-func BenchmarkScaleABSrcGray(b *testing.B)  { benchScale(b, srcGray, 200, 150, ApproxBiLinear) }
-func BenchmarkScaleABSrcNRGBA(b *testing.B) { benchScale(b, srcNRGBA, 200, 150, ApproxBiLinear) }
-func BenchmarkScaleABSrcRGBA(b *testing.B)  { benchScale(b, srcRGBA, 200, 150, ApproxBiLinear) }
-func BenchmarkScaleABSrcYCbCr(b *testing.B) { benchScale(b, srcYCbCr, 200, 150, ApproxBiLinear) }
+func BenchmarkScaleABSrcGray(b *testing.B)  { benchScale(b, 200, 150, Src, srcGray, ApproxBiLinear) }
+func BenchmarkScaleABSrcNRGBA(b *testing.B) { benchScale(b, 200, 150, Src, srcNRGBA, ApproxBiLinear) }
+func BenchmarkScaleABSrcRGBA(b *testing.B)  { benchScale(b, 200, 150, Src, srcRGBA, ApproxBiLinear) }
+func BenchmarkScaleABSrcYCbCr(b *testing.B) { benchScale(b, 200, 150, Src, srcYCbCr, ApproxBiLinear) }
 
-func BenchmarkTformABSrcGray(b *testing.B)  { benchTform(b, srcGray, 200, 150, ApproxBiLinear) }
-func BenchmarkTformABSrcNRGBA(b *testing.B) { benchTform(b, srcNRGBA, 200, 150, ApproxBiLinear) }
-func BenchmarkTformABSrcRGBA(b *testing.B)  { benchTform(b, srcRGBA, 200, 150, ApproxBiLinear) }
-func BenchmarkTformABSrcYCbCr(b *testing.B) { benchTform(b, srcYCbCr, 200, 150, ApproxBiLinear) }
+func BenchmarkTformABSrcGray(b *testing.B)  { benchTform(b, 200, 150, Src, srcGray, ApproxBiLinear) }
+func BenchmarkTformABSrcNRGBA(b *testing.B) { benchTform(b, 200, 150, Src, srcNRGBA, ApproxBiLinear) }
+func BenchmarkTformABSrcRGBA(b *testing.B)  { benchTform(b, 200, 150, Src, srcRGBA, ApproxBiLinear) }
+func BenchmarkTformABSrcYCbCr(b *testing.B) { benchTform(b, 200, 150, Src, srcYCbCr, ApproxBiLinear) }
 
-func BenchmarkScaleCRSrcGray(b *testing.B)  { benchScale(b, srcGray, 200, 150, CatmullRom) }
-func BenchmarkScaleCRSrcNRGBA(b *testing.B) { benchScale(b, srcNRGBA, 200, 150, CatmullRom) }
-func BenchmarkScaleCRSrcRGBA(b *testing.B)  { benchScale(b, srcRGBA, 200, 150, CatmullRom) }
-func BenchmarkScaleCRSrcYCbCr(b *testing.B) { benchScale(b, srcYCbCr, 200, 150, CatmullRom) }
+func BenchmarkScaleCRSrcGray(b *testing.B)  { benchScale(b, 200, 150, Src, srcGray, CatmullRom) }
+func BenchmarkScaleCRSrcNRGBA(b *testing.B) { benchScale(b, 200, 150, Src, srcNRGBA, CatmullRom) }
+func BenchmarkScaleCRSrcRGBA(b *testing.B)  { benchScale(b, 200, 150, Src, srcRGBA, CatmullRom) }
+func BenchmarkScaleCRSrcYCbCr(b *testing.B) { benchScale(b, 200, 150, Src, srcYCbCr, CatmullRom) }
 
-func BenchmarkTformCRSrcGray(b *testing.B)  { benchTform(b, srcGray, 200, 150, CatmullRom) }
-func BenchmarkTformCRSrcNRGBA(b *testing.B) { benchTform(b, srcNRGBA, 200, 150, CatmullRom) }
-func BenchmarkTformCRSrcRGBA(b *testing.B)  { benchTform(b, srcRGBA, 200, 150, CatmullRom) }
-func BenchmarkTformCRSrcYCbCr(b *testing.B) { benchTform(b, srcYCbCr, 200, 150, CatmullRom) }
+func BenchmarkTformCRSrcGray(b *testing.B)  { benchTform(b, 200, 150, Src, srcGray, CatmullRom) }
+func BenchmarkTformCRSrcNRGBA(b *testing.B) { benchTform(b, 200, 150, Src, srcNRGBA, CatmullRom) }
+func BenchmarkTformCRSrcRGBA(b *testing.B)  { benchTform(b, 200, 150, Src, srcRGBA, CatmullRom) }
+func BenchmarkTformCRSrcYCbCr(b *testing.B) { benchTform(b, 200, 150, Src, srcYCbCr, CatmullRom) }