Imported Upstream version 2011.05.22upstream-weekly/2011.05.22

10 files changed, 184 insertions, 21 deletions

diff --git a/src/pkg/exp/datafmt/datafmt.go b/src/pkg/exp/datafmt/datafmt.go
index a8efdc58f..10e4b54f9 100644
--- a/src/pkg/exp/datafmt/datafmt.go
+++ b/src/pkg/exp/datafmt/datafmt.go
@@ -594,7 +594,7 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool {
 		s.eval(t.indent, value, index)
 		// if the indentation evaluates to nil, the state's output buffer
 		// didn't change - either way it's ok to append the difference to
-		// the current identation
+		// the current indentation
 		s.indent.Write(s.output.Bytes()[mark.outputLen:s.output.Len()])
 		s.restore(mark)
 
diff --git a/src/pkg/exp/draw/draw.go b/src/pkg/exp/draw/draw.go
index 1d0729d92..f98e24618 100644
--- a/src/pkg/exp/draw/draw.go
+++ b/src/pkg/exp/draw/draw.go
@@ -8,7 +8,10 @@
 // and the X Render extension.
 package draw
 
-import "image"
+import (
+	"image"
+	"image/ycbcr"
+)
 
 // m is the maximum color value returned by image.Color.RGBA.
 const m = 1<<16 - 1
@@ -65,29 +68,42 @@ func DrawMask(dst Image, r image.Rectangle, src image.Image, sp image.Point, mas
 	if dst0, ok := dst.(*image.RGBA); ok {
 		if op == Over {
 			if mask == nil {
-				if src0, ok := src.(*image.ColorImage); ok {
+				switch src0 := src.(type) {
+				case *image.ColorImage:
 					drawFillOver(dst0, r, src0)
 					return
-				}
-				if src0, ok := src.(*image.RGBA); ok {
+				case *image.RGBA:
 					drawCopyOver(dst0, r, src0, sp)
 					return
+				case *image.NRGBA:
+					drawNRGBAOver(dst0, r, src0, sp)
+					return
+				case *ycbcr.YCbCr:
+					drawYCbCr(dst0, r, src0, sp)
+					return
 				}
 			} else if mask0, ok := mask.(*image.Alpha); ok {
-				if src0, ok := src.(*image.ColorImage); ok {
+				switch src0 := src.(type) {
+				case *image.ColorImage:
 					drawGlyphOver(dst0, r, src0, mask0, mp)
 					return
 				}
 			}
 		} else {
 			if mask == nil {
-				if src0, ok := src.(*image.ColorImage); ok {
+				switch src0 := src.(type) {
+				case *image.ColorImage:
 					drawFillSrc(dst0, r, src0)
 					return
-				}
-				if src0, ok := src.(*image.RGBA); ok {
+				case *image.RGBA:
 					drawCopySrc(dst0, r, src0, sp)
 					return
+				case *image.NRGBA:
+					drawNRGBASrc(dst0, r, src0, sp)
+					return
+				case *ycbcr.YCbCr:
+					drawYCbCr(dst0, r, src0, sp)
+					return
 				}
 			}
 		}
@@ -224,6 +240,36 @@ func drawCopyOver(dst *image.RGBA, r image.Rectangle, src *image.RGBA, sp image.
 	}
 }
 
+func drawNRGBAOver(dst *image.RGBA, r image.Rectangle, src *image.NRGBA, sp image.Point) {
+	for y, sy := r.Min.Y, sp.Y; y != r.Max.Y; y, sy = y+1, sy+1 {
+		dpix := dst.Pix[y*dst.Stride : (y+1)*dst.Stride]
+		spix := src.Pix[sy*src.Stride : (sy+1)*src.Stride]
+		for x, sx := r.Min.X, sp.X; x != r.Max.X; x, sx = x+1, sx+1 {
+			// Convert from non-premultiplied color to pre-multiplied color.
+			// The order of operations here is to match the NRGBAColor.RGBA
+			// method in image/color.go.
+			snrgba := spix[sx]
+			sa := uint32(snrgba.A)
+			sr := uint32(snrgba.R) * 0x101 * sa / 0xff
+			sg := uint32(snrgba.G) * 0x101 * sa / 0xff
+			sb := uint32(snrgba.B) * 0x101 * sa / 0xff
+			sa *= 0x101
+
+			rgba := dpix[x]
+			dr := uint32(rgba.R)
+			dg := uint32(rgba.G)
+			db := uint32(rgba.B)
+			da := uint32(rgba.A)
+			a := (m - sa) * 0x101
+			dr = (dr*a + sr*m) / m
+			dg = (dg*a + sg*m) / m
+			db = (db*a + sb*m) / m
+			da = (da*a + sa*m) / m
+			dpix[x] = image.RGBAColor{uint8(dr >> 8), uint8(dg >> 8), uint8(db >> 8), uint8(da >> 8)}
+		}
+	}
+}
+
 func drawGlyphOver(dst *image.RGBA, r image.Rectangle, src *image.ColorImage, mask *image.Alpha, mp image.Point) {
 	x0, x1 := r.Min.X, r.Max.X
 	y0, y1 := r.Min.Y, r.Max.Y
@@ -311,6 +357,73 @@ func drawCopySrc(dst *image.RGBA, r image.Rectangle, src *image.RGBA, sp image.P
 	}
 }
 
+func drawNRGBASrc(dst *image.RGBA, r image.Rectangle, src *image.NRGBA, sp image.Point) {
+	for y, sy := r.Min.Y, sp.Y; y != r.Max.Y; y, sy = y+1, sy+1 {
+		dpix := dst.Pix[y*dst.Stride : (y+1)*dst.Stride]
+		spix := src.Pix[sy*src.Stride : (sy+1)*src.Stride]
+		for x, sx := r.Min.X, sp.X; x != r.Max.X; x, sx = x+1, sx+1 {
+			// Convert from non-premultiplied color to pre-multiplied color.
+			// The order of operations here is to match the NRGBAColor.RGBA
+			// method in image/color.go.
+			snrgba := spix[sx]
+			sa := uint32(snrgba.A)
+			sr := uint32(snrgba.R) * 0x101 * sa / 0xff
+			sg := uint32(snrgba.G) * 0x101 * sa / 0xff
+			sb := uint32(snrgba.B) * 0x101 * sa / 0xff
+			sa *= 0x101
+
+			dpix[x] = image.RGBAColor{uint8(sr >> 8), uint8(sg >> 8), uint8(sb >> 8), uint8(sa >> 8)}
+		}
+	}
+}
+
+func drawYCbCr(dst *image.RGBA, r image.Rectangle, src *ycbcr.YCbCr, sp image.Point) {
+	// A YCbCr image is always fully opaque, and so if the mask is implicitly nil
+	// (i.e. fully opaque) then the op is effectively always Src.
+	var (
+		yy, cb, cr uint8
+		rr, gg, bb uint8
+	)
+	switch src.SubsampleRatio {
+	case ycbcr.SubsampleRatio422:
+		for y, sy := r.Min.Y, sp.Y; y != r.Max.Y; y, sy = y+1, sy+1 {
+			dpix := dst.Pix[y*dst.Stride : (y+1)*dst.Stride]
+			for x, sx := r.Min.X, sp.X; x != r.Max.X; x, sx = x+1, sx+1 {
+				i := sx / 2
+				yy = src.Y[sy*src.YStride+sx]
+				cb = src.Cb[sy*src.CStride+i]
+				cr = src.Cr[sy*src.CStride+i]
+				rr, gg, bb = ycbcr.YCbCrToRGB(yy, cb, cr)
+				dpix[x] = image.RGBAColor{rr, gg, bb, 255}
+			}
+		}
+	case ycbcr.SubsampleRatio420:
+		for y, sy := r.Min.Y, sp.Y; y != r.Max.Y; y, sy = y+1, sy+1 {
+			dpix := dst.Pix[y*dst.Stride : (y+1)*dst.Stride]
+			for x, sx := r.Min.X, sp.X; x != r.Max.X; x, sx = x+1, sx+1 {
+				i, j := sx/2, sy/2
+				yy = src.Y[sy*src.YStride+sx]
+				cb = src.Cb[j*src.CStride+i]
+				cr = src.Cr[j*src.CStride+i]
+				rr, gg, bb = ycbcr.YCbCrToRGB(yy, cb, cr)
+				dpix[x] = image.RGBAColor{rr, gg, bb, 255}
+			}
+		}
+	default:
+		// Default to 4:4:4 subsampling.
+		for y, sy := r.Min.Y, sp.Y; y != r.Max.Y; y, sy = y+1, sy+1 {
+			dpix := dst.Pix[y*dst.Stride : (y+1)*dst.Stride]
+			for x, sx := r.Min.X, sp.X; x != r.Max.X; x, sx = x+1, sx+1 {
+				yy = src.Y[sy*src.YStride+sx]
+				cb = src.Cb[sy*src.CStride+sx]
+				cr = src.Cr[sy*src.CStride+sx]
+				rr, gg, bb = ycbcr.YCbCrToRGB(yy, cb, cr)
+				dpix[x] = image.RGBAColor{rr, gg, bb, 255}
+			}
+		}
+	}
+}
+
 func drawRGBA(dst *image.RGBA, r image.Rectangle, src image.Image, sp image.Point, mask image.Image, mp image.Point, op Op) {
 	x0, x1, dx := r.Min.X, r.Max.X, 1
 	y0, y1, dy := r.Min.Y, r.Max.Y, 1
diff --git a/src/pkg/exp/draw/draw_test.go b/src/pkg/exp/draw/draw_test.go
index 90c9e823d..873a2f24a 100644
--- a/src/pkg/exp/draw/draw_test.go
+++ b/src/pkg/exp/draw/draw_test.go
@@ -6,6 +6,7 @@ package draw
 
 import (
 	"image"
+	"image/ycbcr"
 	"testing"
 )
 
@@ -43,6 +44,34 @@ func vgradAlpha(alpha int) image.Image {
 	return m
 }
 
+func vgradGreenNRGBA(alpha int) image.Image {
+	m := image.NewNRGBA(16, 16)
+	for y := 0; y < 16; y++ {
+		for x := 0; x < 16; x++ {
+			m.Set(x, y, image.RGBAColor{0, uint8(y * 0x11), 0, uint8(alpha)})
+		}
+	}
+	return m
+}
+
+func vgradCr() image.Image {
+	m := &ycbcr.YCbCr{
+		Y:              make([]byte, 16*16),
+		Cb:             make([]byte, 16*16),
+		Cr:             make([]byte, 16*16),
+		YStride:        16,
+		CStride:        16,
+		SubsampleRatio: ycbcr.SubsampleRatio444,
+		Rect:           image.Rect(0, 0, 16, 16),
+	}
+	for y := 0; y < 16; y++ {
+		for x := 0; x < 16; x++ {
+			m.Cr[y*m.CStride+x] = uint8(y * 0x11)
+		}
+	}
+	return m
+}
+
 func hgradRed(alpha int) Image {
 	m := image.NewRGBA(16, 16)
 	for y := 0; y < 16; y++ {
@@ -95,6 +124,27 @@ var drawTests = []drawTest{
 	{"copyAlphaSrc", vgradGreen(90), fillAlpha(192), Src, image.RGBAColor{0, 36, 0, 68}},
 	{"copyNil", vgradGreen(90), nil, Over, image.RGBAColor{88, 48, 0, 255}},
 	{"copyNilSrc", vgradGreen(90), nil, Src, image.RGBAColor{0, 48, 0, 90}},
+	// Uniform mask (100%, 75%, nil) and variable NRGBA source.
+	// At (x, y) == (8, 8):
+	// The destination pixel is {136, 0, 0, 255}.
+	// The source pixel is {0, 136, 0, 90} in NRGBA-space, which is {0, 48, 0, 90} in RGBA-space.
+	// The result pixel is different than in the "copy*" test cases because of rounding errors.
+	{"nrgba", vgradGreenNRGBA(90), fillAlpha(255), Over, image.RGBAColor{88, 46, 0, 255}},
+	{"nrgbaSrc", vgradGreenNRGBA(90), fillAlpha(255), Src, image.RGBAColor{0, 46, 0, 90}},
+	{"nrgbaAlpha", vgradGreenNRGBA(90), fillAlpha(192), Over, image.RGBAColor{100, 34, 0, 255}},
+	{"nrgbaAlphaSrc", vgradGreenNRGBA(90), fillAlpha(192), Src, image.RGBAColor{0, 34, 0, 68}},
+	{"nrgbaNil", vgradGreenNRGBA(90), nil, Over, image.RGBAColor{88, 46, 0, 255}},
+	{"nrgbaNilSrc", vgradGreenNRGBA(90), nil, Src, image.RGBAColor{0, 46, 0, 90}},
+	// Uniform mask (100%, 75%, nil) and variable YCbCr source.
+	// At (x, y) == (8, 8):
+	// The destination pixel is {136, 0, 0, 255}.
+	// The source pixel is {0, 0, 136} in YCbCr-space, which is {11, 38, 0, 255} in RGB-space.
+	{"ycbcr", vgradCr(), fillAlpha(255), Over, image.RGBAColor{11, 38, 0, 255}},
+	{"ycbcrSrc", vgradCr(), fillAlpha(255), Src, image.RGBAColor{11, 38, 0, 255}},
+	{"ycbcrAlpha", vgradCr(), fillAlpha(192), Over, image.RGBAColor{42, 28, 0, 255}},
+	{"ycbcrAlphaSrc", vgradCr(), fillAlpha(192), Src, image.RGBAColor{8, 28, 0, 192}},
+	{"ycbcrNil", vgradCr(), nil, Over, image.RGBAColor{11, 38, 0, 255}},
+	{"ycbcrNilSrc", vgradCr(), nil, Src, image.RGBAColor{11, 38, 0, 255}},
 	// Variable mask and variable source.
 	// At (x, y) == (8, 8):
 	// The destination pixel is {136, 0, 0, 255}.
diff --git a/src/pkg/exp/draw/x11/conn.go b/src/pkg/exp/draw/x11/conn.go
index 81c67267d..23edc2c63 100644
--- a/src/pkg/exp/draw/x11/conn.go
+++ b/src/pkg/exp/draw/x11/conn.go
@@ -310,7 +310,7 @@ func authenticate(w *bufio.Writer, displayStr string) os.Error {
 		return os.NewError("unsupported Xauth")
 	}
 	// 0x006c means little-endian. 0x000b, 0x0000 means X major version 11, minor version 0.
-	// 0x0012 and 0x0010 means the auth key and value have lenths 18 and 16.
+	// 0x0012 and 0x0010 means the auth key and value have lengths 18 and 16.
 	// The final 0x0000 is padding, so that the string length is a multiple of 4.
 	_, err = io.WriteString(w, "\x6c\x00\x0b\x00\x00\x00\x12\x00\x10\x00\x00\x00")
 	if err != nil {
@@ -517,7 +517,7 @@ func (c *conn) handshake() os.Error {
 	if err != nil {
 		return err
 	}
-	// Ignore some things that we don't care about (totalling 10 + vendorLen bytes):
+	// Ignore some things that we don't care about (totaling 10 + vendorLen bytes):
 	// imageByteOrder(1), bitmapFormatBitOrder(1), bitmapFormatScanlineUnit(1) bitmapFormatScanlinePad(1),
 	// minKeycode(1), maxKeycode(1), padding(4), vendor (vendorLen).
 	if 10+int(vendorLen) > cap(c.buf) {
diff --git a/src/pkg/exp/eval/expr.go b/src/pkg/exp/eval/expr.go
index e65f47617..14a0659b6 100644
--- a/src/pkg/exp/eval/expr.go
+++ b/src/pkg/exp/eval/expr.go
@@ -1781,7 +1781,7 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr {
 		// written: Function values are equal if they were
 		// created by the same execution of a function literal
 		// or refer to the same function declaration.  This is
-		// *almost* but not quite waht 6g implements.  If a
+		// *almost* but not quite what 6g implements.  If a
 		// function literals does not capture any variables,
 		// then multiple executions of it will result in the
 		// same closure.  Russ says he'll change that.
diff --git a/src/pkg/exp/eval/stmt.go b/src/pkg/exp/eval/stmt.go
index f6b7c1cda..57bf20e6f 100644
--- a/src/pkg/exp/eval/stmt.go
+++ b/src/pkg/exp/eval/stmt.go
@@ -68,7 +68,7 @@ type flowBuf struct {
 	gotos map[token.Pos]*flowBlock
 	// labels is a map from label name to information on the block
 	// at the point of the label.  labels are tracked by name,
-	// since mutliple labels at the same PC can have different
+	// since multiple labels at the same PC can have different
 	// blocks.
 	labels map[string]*flowBlock
 }
@@ -307,7 +307,7 @@ func (a *stmtCompiler) compile(s ast.Stmt) {
 	}
 
 	if notimpl {
-		a.diag("%T statment node not implemented", s)
+		a.diag("%T statement node not implemented", s)
 	}
 
 	if a.block.inner != nil {
@@ -550,7 +550,7 @@ func (a *stmtCompiler) doAssign(lhs []ast.Expr, rhs []ast.Expr, tok token.Token,
 			ident, ok = le.(*ast.Ident)
 			if !ok {
 				a.diagAt(le.Pos(), "left side of := must be a name")
-				// Suppress new defitions errors
+				// Suppress new definitions errors
 				nDefs++
 				continue
 			}
diff --git a/src/pkg/exp/eval/typec.go b/src/pkg/exp/eval/typec.go
index de90cf664..0ed24a8d2 100644
--- a/src/pkg/exp/eval/typec.go
+++ b/src/pkg/exp/eval/typec.go
@@ -68,7 +68,7 @@ func (a *typeCompiler) compileArrayType(x *ast.ArrayType, allowRec bool) Type {
 	}
 
 	if _, ok := x.Len.(*ast.Ellipsis); ok {
-		a.diagAt(x.Len.Pos(), "... array initailizers not implemented")
+		a.diagAt(x.Len.Pos(), "... array initializers not implemented")
 		return nil
 	}
 	l, ok := a.compileArrayLen(a.block, x.Len)
diff --git a/src/pkg/exp/wingui/Makefile b/src/pkg/exp/wingui/Makefile
index 983a8270b..e382c019f 100644
--- a/src/pkg/exp/wingui/Makefile
+++ b/src/pkg/exp/wingui/Makefile
@@ -18,7 +18,7 @@ GOFILES=\
 include ../../../Make.cmd
 
 zwinapi.go: winapi.go
-	$(GOROOT)/src/pkg/syscall/mksyscall_windows.sh $< \
+	$(GOROOT)/src/pkg/syscall/mksyscall_windows.pl $< \
 		| sed 's/^package.*syscall$$/package main/' \
 		| sed '/^import/a \
 			import "syscall"' \
diff --git a/src/pkg/exp/wingui/winapi.go b/src/pkg/exp/wingui/winapi.go
index c96f45299..fb0d61009 100644
--- a/src/pkg/exp/wingui/winapi.go
+++ b/src/pkg/exp/wingui/winapi.go
@@ -96,7 +96,7 @@ const (
 	// Some button control styles
 	BS_DEFPUSHBUTTON = 1
 
-	// Some colour constants
+	// Some color constants
 	COLOR_WINDOW  = 5
 	COLOR_BTNFACE = 15
 
@@ -108,13 +108,13 @@ const (
 )
 
 var (
-	// Some globaly known cusrors
+	// Some globally known cursors
 	IDC_ARROW = MakeIntResource(32512)
 	IDC_IBEAM = MakeIntResource(32513)
 	IDC_WAIT  = MakeIntResource(32514)
 	IDC_CROSS = MakeIntResource(32515)
 
-	// Some globaly known icons
+	// Some globally known icons
 	IDI_APPLICATION = MakeIntResource(32512)
 	IDI_HAND        = MakeIntResource(32513)
 	IDI_QUESTION    = MakeIntResource(32514)
diff --git a/src/pkg/exp/wingui/zwinapi.go b/src/pkg/exp/wingui/zwinapi.go
index 60aaac6cf..6ae6330a1 100644
--- a/src/pkg/exp/wingui/zwinapi.go
+++ b/src/pkg/exp/wingui/zwinapi.go
@@ -1,4 +1,4 @@
-// mksyscall_windows.sh winapi.go
+// mksyscall_windows.pl winapi.go
 // MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
 
 package main