7179526: xrender : closed/sun/java2d/volatileImage/LineClipTest.java failed since jdk8b36
Reviewed-by: prr, jchen
--- a/jdk/src/solaris/classes/sun/java2d/xr/GrowableRectArray.java Wed Oct 02 11:16:07 2013 -0700
+++ b/jdk/src/solaris/classes/sun/java2d/xr/GrowableRectArray.java Wed Oct 02 11:22:07 2013 -0700
@@ -38,6 +38,20 @@
super(RECT_SIZE, initialSize);
}
+ public final void pushRectValues(int x, int y, int width, int height) {
+ int currSize = size;
+ size += RECT_SIZE;
+
+ if (size >= array.length) {
+ growArray();
+ }
+
+ array[currSize] = x;
+ array[currSize + 1] = y;
+ array[currSize + 2] = width;
+ array[currSize + 3] = height;
+ }
+
public final void setX(int index, int x) {
array[getCellIndex(index)] = x;
}
--- a/jdk/src/solaris/classes/sun/java2d/xr/MaskTile.java Wed Oct 02 11:16:07 2013 -0700
+++ b/jdk/src/solaris/classes/sun/java2d/xr/MaskTile.java Wed Oct 02 11:22:07 2013 -0700
@@ -41,98 +41,6 @@
dirtyArea = new DirtyRegion();
}
- public void addRect(int x, int y, int width, int height) {
- int index = rects.getNextIndex();
- rects.setX(index, x);
- rects.setY(index, y);
- rects.setWidth(index, width);
- rects.setHeight(index, height);
- }
-
- public void addLine(int x1, int y1, int x2, int y2) {
- /*
- * EXA is not able to accalerate diagonal lines, we try to "guide" it a
- * bit to avoid excessive migration See project documentation for an
- * detailed explanation
- */
- DirtyRegion region = new DirtyRegion();
- region.setDirtyLineRegion(x1, y1, x2, y2);
- int xDiff = region.x2 - region.x;
- int yDiff = region.y2 - region.y;
-
- if (xDiff == 0 || yDiff == 0) {
- addRect(region.x, region.y,
- region.x2 - region.x + 1, region.y2 - region.y + 1);
- } else if (xDiff == 1 && yDiff == 1) {
- addRect(x1, y1, 1, 1);
- addRect(x2, y2, 1, 1);
- } else {
- lineToRects(x1, y1, x2, y2);
- }
- }
-
- private void lineToRects(int xstart, int ystart, int xend, int yend) {
- int x, y, t, dx, dy, incx, incy, pdx, pdy, ddx, ddy, es, el, err;
-
- /* Entfernung in beiden Dimensionen berechnen */
- dx = xend - xstart;
- dy = yend - ystart;
-
- /* Vorzeichen des Inkrements bestimmen */
- incx = dx > 0 ? 1 : (dx < 0) ? -1 : 0;
- incy = dy > 0 ? 1 : (dy < 0) ? -1 : 0;
- if (dx < 0)
- dx = -dx;
- if (dy < 0)
- dy = -dy;
-
- /* feststellen, welche Entfernung groesser ist */
- if (dx > dy) {
- /* x ist schnelle Richtung */
- pdx = incx;
- pdy = 0; /* pd. ist Parallelschritt */
- ddx = incx;
- ddy = incy; /* dd. ist Diagonalschritt */
- es = dy;
- el = dx; /* Fehlerschritte schnell, langsam */
- } else {
- /* y ist schnelle Richtung */
- pdx = 0;
- pdy = incy; /* pd. ist Parallelschritt */
- ddx = incx;
- ddy = incy; /* dd. ist Diagonalschritt */
- es = dx;
- el = dy; /* Fehlerschritte schnell, langsam */
- }
-
- /* Initialisierungen vor Schleifenbeginn */
- x = xstart;
- y = ystart;
- err = el / 2;
- addRect(x, y, 1, 1);
-
- /* Pixel berechnen */
- for (t = 0; t < el; ++t) /* t zaehlt die Pixel, el ist auch Anzahl */
- {
- /* Aktualisierung Fehlerterm */
- err -= es;
- if (err < 0) {
- /* Fehlerterm wieder positiv (>=0) machen */
- err += el;
- /* Schritt in langsame Richtung, Diagonalschritt */
- x += ddx;
- y += ddy;
- } else {
- /* Schritt in schnelle Richtung, Parallelschritt */
- x += pdx;
- y += pdy;
- }
- addRect(x, y, 1, 1);
- // SetPixel(x,y);
- // System.out.println(x+":"+y);
- }
- }
-
public void calculateDirtyAreas()
{
for (int i=0; i < rects.getSize(); i++) {
--- a/jdk/src/solaris/classes/sun/java2d/xr/MaskTileManager.java Wed Oct 02 11:16:07 2013 -0700
+++ b/jdk/src/solaris/classes/sun/java2d/xr/MaskTileManager.java Wed Oct 02 11:22:07 2013 -0700
@@ -54,10 +54,6 @@
int maskPixmap;
int maskPicture;
long maskGC;
- int lineMaskPixmap;
- int lineMaskPicture;
- long drawLineGC;
- long clearLineGC;
public MaskTileManager(XRCompositeManager xrMgr, int parentXid) {
tileList = new ArrayList<MaskTile>();
@@ -71,34 +67,6 @@
0, 0, MASK_SIZE, MASK_SIZE);
maskGC = con.createGC(maskPixmap);
con.setGCExposures(maskGC, false);
-
- lineMaskPixmap = con.createPixmap(parentXid, 8, MASK_SIZE, MASK_SIZE);
- lineMaskPicture =
- con.createPicture(lineMaskPixmap, XRUtils.PictStandardA8);
- con.renderRectangle(lineMaskPicture, XRUtils.PictOpClear,
- new XRColor(Color.black), 0, 0, MASK_SIZE, MASK_SIZE);
-
- drawLineGC = con.createGC(lineMaskPixmap);
- con.setGCExposures(drawLineGC, false);
- con.setGCForeground(drawLineGC, 255);
-
- clearLineGC = con.createGC(lineMaskPixmap);
- con.setGCExposures(clearLineGC, false);
- con.setGCForeground(clearLineGC, 0);
- }
-
- /**
- * Adds a rectangle to the mask.
- */
- public void addRect(int x, int y, int width, int height) {
- mainTile.addRect(x, y, width, height);
- }
-
- /**
- * Adds a line to the mask.
- */
- public void addLine(int x1, int y1, int x2, int y2) {
- mainTile.addLine(x1, y1, x2, y2);
}
/**
@@ -324,4 +292,11 @@
rects.setY(index, 0);
}
}
+
+ /**
+ * @return MainTile to which rectangles are added before composition.
+ */
+ public MaskTile getMainTile() {
+ return mainTile;
+ }
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/solaris/classes/sun/java2d/xr/XRDrawLine.java Wed Oct 02 11:22:07 2013 -0700
@@ -0,0 +1,425 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+
+
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * Bresenham line-drawing implementation decomposing line segments
+ * into a series of rectangles.
+ * This is required, because xrender doesn't support line primitives directly.
+ * The code here is an almost 1:1 port of the existing C-source contained in
+ * sun/java2d/loop/DrawLine.c and sun/java2d/loop/LoopMacros.h
+ */
+package sun.java2d.xr;
+
+public class XRDrawLine {
+ static final int BIG_MAX = ((1 << 29) - 1);
+ static final int BIG_MIN = (-(1 << 29));
+
+ static final int OUTCODE_TOP = 1;
+ static final int OUTCODE_BOTTOM = 2;
+ static final int OUTCODE_LEFT = 4;
+ static final int OUTCODE_RIGHT = 8;
+
+ int x1, y1, x2, y2;
+ int ucX1, ucY1, ucX2, ucY2;
+
+ DirtyRegion region = new DirtyRegion();
+
+ protected void rasterizeLine(GrowableRectArray rectBuffer, int _x1,
+ int _y1, int _x2, int _y2, int cxmin, int cymin, int cxmax,
+ int cymax, boolean clip, boolean overflowCheck) {
+ float diagF;
+ int error;
+ int steps;
+ int errminor, errmajor;
+ boolean xmajor;
+ int dx, dy, ax, ay;
+
+ initCoordinates(_x1, _y1, _x2, _y2, overflowCheck);
+
+ dx = x2 - x1;
+ dy = y2 - y1;
+ ax = Math.abs(dx);
+ ay = Math.abs(dy);
+ xmajor = (ax >= ay);
+ diagF = ((float) ax) / ay;
+
+ if (clip
+ && !clipCoordinates(cxmin, cymin, cxmax, cymax, xmajor, dx, dy,
+ ax, ay)) {
+ // whole line was clipped away
+ return;
+ }
+
+ region.setDirtyLineRegion(x1, y1, x2, y2);
+ int xDiff = region.x2 - region.x;
+ int yDiff = region.y2 - region.y;
+
+ if (xDiff == 0 || yDiff == 0) {
+ // horizontal / diagonal lines can be represented by a single
+ // rectangle
+ rectBuffer.pushRectValues(region.x, region.y, region.x2 - region.x
+ + 1, region.y2 - region.y + 1);
+ return;
+ }
+
+ // Setup bresenham
+ if (xmajor) {
+ errmajor = ay * 2;
+ errminor = ax * 2;
+ ax = -ax; /* For clipping adjustment below */
+ steps = x2 - x1;
+ } else {
+ errmajor = ax * 2;
+ errminor = ay * 2;
+ ay = -ay; /* For clipping adjustment below */
+ steps = y2 - y1;
+ }
+
+ if ((steps = (Math.abs(steps) + 1)) == 0) {
+ return;
+ }
+
+ error = -(errminor / 2);
+
+ if (y1 != ucY1) {
+ int ysteps = y1 - ucY1;
+ if (ysteps < 0) {
+ ysteps = -ysteps;
+ }
+ error += ysteps * ax * 2;
+ }
+
+ if (x1 != ucX1) {
+ int xsteps = x1 - ucX1;
+ if (xsteps < 0) {
+ xsteps = -xsteps;
+ }
+ error += xsteps * ay * 2;
+ }
+ error += errmajor;
+ errminor -= errmajor;
+
+ int xStep = (dx > 0 ? 1 : -1);
+ int yStep = (dy > 0 ? 1 : -1);
+ int orthogonalXStep = xmajor ? xStep : 0;
+ int orthogonalYStep = !xmajor ? yStep : 0;
+
+ /*
+ * For lines which proceed in one direction faster, we try to generate
+ * rectangles instead of points. Otherwise we try to avoid the extra
+ * work...
+ */
+ if (diagF <= 0.9 || diagF >= 1.1) {
+ lineToRects(rectBuffer, steps, error, errmajor, errminor, xStep,
+ yStep, orthogonalXStep, orthogonalYStep);
+ } else {
+ lineToPoints(rectBuffer, steps, error, errmajor, errminor, xStep,
+ yStep, orthogonalXStep, orthogonalYStep);
+ }
+ }
+
+ private void lineToPoints(GrowableRectArray rectBuffer, int steps,
+ int error, int errmajor, int errminor, int xStep, int yStep,
+ int orthogonalXStep, int orthogonalYStep) {
+ int x = x1, y = y1;
+
+ do {
+ rectBuffer.pushRectValues(x, y, 1, 1);
+
+ // "Traditional" Bresenham line drawing
+ if (error < 0) {
+ error += errmajor;
+ x += orthogonalXStep;
+ y += orthogonalYStep;
+ } else {
+ error -= errminor;
+ x += xStep;
+ y += yStep;
+ }
+ } while (--steps > 0);
+ }
+
+ private void lineToRects(GrowableRectArray rectBuffer, int steps,
+ int error, int errmajor, int errminor, int xStep, int yStep,
+ int orthogonalXStep, int orthogonalYStep) {
+ int x = x1, y = y1;
+ int rectX = Integer.MIN_VALUE, rectY = 0;
+ int rectW = 0, rectH = 0;
+
+ do {
+ // Combine the resulting rectangles
+ // for steps performed in a single direction.
+ if (y == rectY) {
+ if (x == (rectX + rectW)) {
+ rectW++;
+ } else if (x == (rectX - 1)) {
+ rectX--;
+ rectW++;
+ }
+ } else if (x == rectX) {
+ if (y == (rectY + rectH)) {
+ rectH++;
+ } else if (y == (rectY - 1)) {
+ rectY--;
+ rectH++;
+ }
+ } else {
+ // Diagonal step: add the previous rectangle to the list,
+ // iff it was "real" (= not initialized before the first
+ // iteration)
+ if (rectX != Integer.MIN_VALUE) {
+ rectBuffer.pushRectValues(rectX, rectY, rectW, rectH);
+ }
+ rectX = x;
+ rectY = y;
+ rectW = rectH = 1;
+ }
+
+ // "Traditional" Bresenham line drawing
+ if (error < 0) {
+ error += errmajor;
+ x += orthogonalXStep;
+ y += orthogonalYStep;
+ } else {
+ error -= errminor;
+ x += xStep;
+ y += yStep;
+ }
+ } while (--steps > 0);
+
+ // Add last rectangle which isn't handled by the combination-code
+ // anymore
+ rectBuffer.pushRectValues(rectX, rectY, rectW, rectH);
+ }
+
+ private boolean clipCoordinates(int cxmin, int cymin, int cxmax, int cymax,
+ boolean xmajor, int dx, int dy, int ax, int ay) {
+ int outcode1, outcode2;
+
+ outcode1 = outcode(x1, y1, cxmin, cymin, cxmax, cymax);
+ outcode2 = outcode(x2, y2, cxmin, cymin, cxmax, cymax);
+
+ while ((outcode1 | outcode2) != 0) {
+ int xsteps = 0, ysteps = 0;
+
+ if ((outcode1 & outcode2) != 0) {
+ return false;
+ }
+
+ if (outcode1 != 0) {
+ if ((outcode1 & (OUTCODE_TOP | OUTCODE_BOTTOM)) != 0) {
+ if ((outcode1 & OUTCODE_TOP) != 0) {
+ y1 = cymin;
+ } else {
+ y1 = cymax;
+ }
+ ysteps = y1 - ucY1;
+ if (ysteps < 0) {
+ ysteps = -ysteps;
+ }
+ xsteps = 2 * ysteps * ax + ay;
+ if (xmajor) {
+ xsteps += ay - ax - 1;
+ }
+ xsteps = xsteps / (2 * ay);
+ if (dx < 0) {
+ xsteps = -xsteps;
+ }
+ x1 = ucX1 + (int) xsteps;
+ } else if ((outcode1 & (OUTCODE_LEFT | OUTCODE_RIGHT)) != 0) {
+ if ((outcode1 & OUTCODE_LEFT) != 0) {
+ x1 = cxmin;
+ } else {
+ x1 = cxmax;
+ }
+ xsteps = x1 - ucX1;
+ if (xsteps < 0) {
+ xsteps = -xsteps;
+ }
+ ysteps = 2 * xsteps * ay + ax;
+ if (!xmajor) {
+ ysteps += ax - ay - 1;
+ }
+ ysteps = ysteps / (2 * ax);
+ if (dy < 0) {
+ ysteps = -ysteps;
+ }
+ y1 = ucY1 + (int) ysteps;
+ }
+ outcode1 = outcode(x1, y1, cxmin, cymin, cxmax, cymax);
+ } else {
+ if ((outcode2 & (OUTCODE_TOP | OUTCODE_BOTTOM)) != 0) {
+ if ((outcode2 & OUTCODE_TOP) != 0) {
+ y2 = cymin;
+ } else {
+ y2 = cymax;
+ }
+ ysteps = y2 - ucY2;
+ if (ysteps < 0) {
+ ysteps = -ysteps;
+ }
+ xsteps = 2 * ysteps * ax + ay;
+ if (xmajor) {
+ xsteps += ay - ax;
+ } else {
+ xsteps -= 1;
+ }
+ xsteps = xsteps / (2 * ay);
+ if (dx > 0) {
+ xsteps = -xsteps;
+ }
+ x2 = ucX2 + (int) xsteps;
+ } else if ((outcode2 & (OUTCODE_LEFT | OUTCODE_RIGHT)) != 0) {
+ if ((outcode2 & OUTCODE_LEFT) != 0) {
+ x2 = cxmin;
+ } else {
+ x2 = cxmax;
+ }
+ xsteps = x2 - ucX2;
+ if (xsteps < 0) {
+ xsteps = -xsteps;
+ }
+ ysteps = 2 * xsteps * ay + ax;
+ if (xmajor) {
+ ysteps -= 1;
+ } else {
+ ysteps += ax - ay;
+ }
+ ysteps = ysteps / (2 * ax);
+ if (dy > 0) {
+ ysteps = -ysteps;
+ }
+ y2 = ucY2 + (int) ysteps;
+ }
+ outcode2 = outcode(x2, y2, cxmin, cymin, cxmax, cymax);
+ }
+ }
+
+ return true;
+ }
+
+ private void initCoordinates(int x1, int y1, int x2, int y2,
+ boolean checkOverflow) {
+ /*
+ * Part of calculating the Bresenham parameters for line stepping
+ * involves being able to store numbers that are twice the magnitude of
+ * the biggest absolute difference in coordinates. Since we want the
+ * stepping parameters to be stored in jints, we then need to avoid any
+ * absolute differences more than 30 bits. Thus, we need to preprocess
+ * the coordinates to reduce their range to 30 bits regardless of
+ * clipping. We need to cut their range back before we do the clipping
+ * because the Bresenham stepping values need to be calculated based on
+ * the "unclipped" coordinates.
+ *
+ * Thus, first we perform a "pre-clipping" stage to bring the
+ * coordinates within the 30-bit range and then we proceed to the
+ * regular clipping procedure, pretending that these were the original
+ * coordinates all along. Since this operation occurs based on a
+ * constant "pre-clip" rectangle of +/- 30 bits without any
+ * consideration for the final clip, the rounding errors that occur here
+ * will depend only on the line coordinates and be invariant with
+ * respect to the particular device/user clip rectangles in effect at
+ * the time. Thus, rendering a given large-range line will be consistent
+ * under a variety of clipping conditions.
+ */
+ if (checkOverflow
+ && (OverflowsBig(x1) || OverflowsBig(y1) || OverflowsBig(x2) || OverflowsBig(y2))) {
+ /*
+ * Use doubles to get us into range for "Big" arithmetic.
+ *
+ * The math of adjusting an endpoint for clipping can involve an
+ * intermediate result with twice the number of bits as the original
+ * coordinate range. Since we want to maintain as much as 30 bits of
+ * precision in the resulting coordinates, we will get roundoff here
+ * even using IEEE double-precision arithmetic which cannot carry 60
+ * bits of mantissa. Since the rounding errors will be consistent
+ * for a given set of input coordinates the potential roundoff error
+ * should not affect the consistency of our rendering.
+ */
+ double x1d = x1;
+ double y1d = y1;
+ double x2d = x2;
+ double y2d = y2;
+ double dxd = x2d - x1d;
+ double dyd = y2d - y1d;
+
+ if (x1 < BIG_MIN) {
+ y1d = y1 + (BIG_MIN - x1) * dyd / dxd;
+ x1d = BIG_MIN;
+ } else if (x1 > BIG_MAX) {
+ y1d = y1 - (x1 - BIG_MAX) * dyd / dxd;
+ x1d = BIG_MAX;
+ }
+ /* Use Y1d instead of _y1 for testing now as we may have modified it */
+ if (y1d < BIG_MIN) {
+ x1d = x1 + (BIG_MIN - y1) * dxd / dyd;
+ y1d = BIG_MIN;
+ } else if (y1d > BIG_MAX) {
+ x1d = x1 - (y1 - BIG_MAX) * dxd / dyd;
+ y1d = BIG_MAX;
+ }
+ if (x2 < BIG_MIN) {
+ y2d = y2 + (BIG_MIN - x2) * dyd / dxd;
+ x2d = BIG_MIN;
+ } else if (x2 > BIG_MAX) {
+ y2d = y2 - (x2 - BIG_MAX) * dyd / dxd;
+ x2d = BIG_MAX;
+ }
+ /* Use Y2d instead of _y2 for testing now as we may have modified it */
+ if (y2d < BIG_MIN) {
+ x2d = x2 + (BIG_MIN - y2) * dxd / dyd;
+ y2d = BIG_MIN;
+ } else if (y2d > BIG_MAX) {
+ x2d = x2 - (y2 - BIG_MAX) * dxd / dyd;
+ y2d = BIG_MAX;
+ }
+
+ x1 = (int) x1d;
+ y1 = (int) y1d;
+ x2 = (int) x2d;
+ y2 = (int) y2d;
+ }
+
+ this.x1 = ucX1 = x1;
+ this.y1 = ucY1 = y1;
+ this.x2 = ucX2 = x2;
+ this.y2 = ucY2 = y2;
+ }
+
+ private boolean OverflowsBig(int v) {
+ return ((v) != (((v) << 2) >> 2));
+ }
+
+ private int out(int v, int vmin, int vmax, int cmin, int cmax) {
+ return ((v < vmin) ? cmin : ((v > vmax) ? cmax : 0));
+ }
+
+ private int outcode(int x, int y, int xmin, int ymin, int xmax, int ymax) {
+ return out(y, ymin, ymax, OUTCODE_TOP, OUTCODE_BOTTOM)
+ | out(x, xmin, xmax, OUTCODE_LEFT, OUTCODE_RIGHT);
+ }
+}
--- a/jdk/src/solaris/classes/sun/java2d/xr/XRRenderer.java Wed Oct 02 11:16:07 2013 -0700
+++ b/jdk/src/solaris/classes/sun/java2d/xr/XRRenderer.java Wed Oct 02 11:22:07 2013 -0700
@@ -53,10 +53,15 @@
public class XRRenderer implements PixelDrawPipe, PixelFillPipe, ShapeDrawPipe {
XRDrawHandler drawHandler;
MaskTileManager tileManager;
+ XRDrawLine lineGen;
+ GrowableRectArray rectBuffer;
public XRRenderer(MaskTileManager tileManager) {
this.tileManager = tileManager;
+ this.rectBuffer = tileManager.getMainTile().getRects();
+
this.drawHandler = new XRDrawHandler();
+ this.lineGen = new XRDrawLine();
}
/**
@@ -77,19 +82,15 @@
int transX2 = Region.clipAdd(x2, sg2d.transX);
int transY2 = Region.clipAdd(y2, sg2d.transY);
- // Non clipped fast path
- if (compClip.contains(transX1, transY1)
- && compClip.contains(transX2, transY2)) {
- SunToolkit.awtLock();
- try {
- validateSurface(sg2d);
- tileManager.addLine(transX1, transY1, transX2, transY2);
- tileManager.fillMask((XRSurfaceData) sg2d.surfaceData);
- } finally {
- SunToolkit.awtUnlock();
- }
- } else {
- draw(sg2d, new Line2D.Float(x1, y1, x2, y2));
+ SunToolkit.awtLock();
+ try {
+ validateSurface(sg2d);
+ lineGen.rasterizeLine(rectBuffer, transX1, transY1,
+ transX2, transY2, compClip.getLoX(), compClip.getLoY(),
+ compClip.getHiX(), compClip.getHiY(), true, true);
+ tileManager.fillMask((XRSurfaceData) sg2d.surfaceData);
+ } finally {
+ SunToolkit.awtUnlock();
}
}
@@ -148,7 +149,7 @@
SunToolkit.awtLock();
try {
validateSurface(sg2d);
- tileManager.addRect(x, y, width, height);
+ rectBuffer.pushRectValues(x, y, width, height);
tileManager.fillMask((XRSurfaceData) sg2d.surfaceData);
} finally {
SunToolkit.awtUnlock();
@@ -199,11 +200,13 @@
}
private class XRDrawHandler extends ProcessPath.DrawHandler {
+ DirtyRegion region;
XRDrawHandler() {
// these are bogus values; the caller will use validate()
// to ensure that they are set properly prior to each usage
super(0, 0, 0, 0);
+ this.region = new DirtyRegion();
}
/**
@@ -218,15 +221,32 @@
}
public void drawLine(int x1, int y1, int x2, int y2) {
- tileManager.addLine(x1, y1, x2, y2);
+ region.setDirtyLineRegion(x1, y1, x2, y2);
+ int xDiff = region.x2 - region.x;
+ int yDiff = region.y2 - region.y;
+
+ if (xDiff == 0 || yDiff == 0) {
+ // horizontal / diagonal lines can be represented by a single
+ // rectangle
+ rectBuffer.pushRectValues(region.x, region.y, region.x2 - region.x
+ + 1, region.y2 - region.y + 1);
+ } else if (xDiff == 1 && yDiff == 1) {
+ // fast path for pattern commonly generated by
+ // ProcessPath.DrawHandler
+ rectBuffer.pushRectValues(x1, y1, 1, 1);
+ rectBuffer.pushRectValues(x2, y2, 1, 1);
+ } else {
+ lineGen.rasterizeLine(rectBuffer, x1, y1, x2, y2, 0, 0,
+ 0, 0, false, false);
+ }
}
public void drawPixel(int x, int y) {
- tileManager.addRect(x, y, 1, 1);
+ rectBuffer.pushRectValues(x, y, 1, 1);
}
public void drawScanline(int x1, int x2, int y) {
- tileManager.addRect(x1, y, x2 - x1 + 1, 1);
+ rectBuffer.pushRectValues(x1, y, x2 - x1 + 1, 1);
}
}
@@ -263,7 +283,7 @@
validateSurface(sg2d);
int[] spanBox = new int[4];
while (si.nextSpan(spanBox)) {
- tileManager.addRect(spanBox[0] + transx,
+ rectBuffer.pushRectValues(spanBox[0] + transx,
spanBox[1] + transy,
spanBox[2] - spanBox[0],
spanBox[3] - spanBox[1]);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/awt/Graphics/LineClipTest.java Wed Oct 02 11:22:07 2013 -0700
@@ -0,0 +1,504 @@
+/*
+ * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @bug 4780022 4862193 7179526
+ * @summary Tests that clipped lines are drawn over the same pixels
+ * as unclipped lines (within the clip bounds)
+ * @run main/timeout=600/othervm -Dsun.java2d.ddforcevram=true LineClipTest
+ * @run main/timeout=600/othervm LineClipTest
+ */
+
+
+/**
+ * This app tests whether we are drawing clipped lines the same
+ * as unclipped lines. The problem occurred when we started
+ * clipping d3d lines using simple integer clipping, which did not
+ * account for sub-pixel precision and ended up drawing very different
+ * pixels than the same line drawn unclipped. A supposed fix
+ * to that problem used floating-point clipping instead, but there
+ * was some problem with very limited precision inside of d3d
+ * (presumably in hardware) that caused some variation in pixels.
+ * We decided that whatever the fix was, we needed a serious
+ * line check test to make sure that all kinds of different
+ * lines would be drawn exactly the same inside the clip area,
+ * regardless of whether clipping was enabled. This test should
+ * check all kinds of different cases, such as lines that fall
+ * completely outside, completely inside, start outside and
+ * end inside, etc., and lines should end and originate in
+ * all quadrants of the space divided up by the clip box.
+ *
+ * The test works as follows:
+ * We create nine quadrants using the spaces bisected by the
+ * edges of the clip bounds (note that only one of these
+ * quadrants is actually visible when clipping is enabled).
+ * We create several points in each of these quadrants
+ * (three in each of the invisible quadrants, nine in the
+ * center/visible quadrant). Our resulting grid looks like
+ * this:
+ *
+ * x x|x x x|x x
+ * | |
+ * | |
+ * | |
+ * | |
+ * | |
+ * x | | x
+ * -----------------------------------
+ * x |x x x| x
+ * | |
+ * | |
+ * x |x x x| x
+ * | |
+ * | |
+ * x |x x x| x
+ * -----------------------------------
+ * x | | x
+ * | |
+ * | |
+ * | |
+ * | |
+ * | |
+ * x x|x x x|x x
+ *
+ * The test then draws lines from every point to every other
+ * point. First, we draw unclipped lines in blue and
+ * then we draw clipped lines in red.
+ * At certain times (after every point during the default
+ * test, after every quadrant of lines if you run with the -quick
+ * option), we check for errors and draw the current image
+ * to the screen. Error checking consists of copying the
+ * VolatileImage to a BufferedImage (because we need access
+ * to the pixels directly) and checking every pixel in the
+ * image. The check is simple: everything outside the
+ * clip bounds should be blue (or the background color) and
+ * everything inside the clip bounds should be red (or the
+ * background color). So any blue pixel inside or red
+ * pixel outside means that there was a drawing error and
+ * the test fails.
+ * There are 4 modes that the test can run in (dynamic mode is
+ * exclusive to the other modes, but the other modes are combinable):
+ *
+ * (default): the clip is set
+ * to a default size (100x100) and the test is run.
+ *
+ * -quick: The error
+ * check is run only after every quadrant of lines is
+ * drawn. This speeds up the test considerably with
+ * some less accuracy in error checking (because pixels
+ * from some lines may overdrawn pixels from other lines
+ * before we have verified the correctness of those
+ * pixels).
+ *
+ * -dynamic: There is no error checking, but this version
+ * of the test automatically resizes the clip bounds and
+ * reruns the test over and over. Nothing besides the
+ * visual check verifies that the test is running correctly.
+ *
+ * -rect: Instead of drawing lines, the test draws rectangles
+ * to/from all points in all quadrants. This tests similar
+ * clipping functionality for drawRect().
+ *
+ * n (where "n" is a number): sets the clip size to the
+ * given value. Just like the default test except that
+ * the clip size is as specified.
+ *
+ * Note: this test must be run with the -Dsun.java2d.ddforcevram=true
+ * option to force the test image to stay in VRAM. We currently
+ * punt VRAM images to system memory when we detect lots of
+ * reads. Since we read the whole buffer on every error check
+ * to copy it to the BufferedImage), this causes us to punt the
+ * buffer. A system memory surface will have no d3d capabilities,
+ * thus we are not testing the d3d line quality when this happens.
+ * By using the ddforcevram flag, we make sure the buffer
+ * stays put in VRAM and d3d is used to draw the lines.
+ */
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.image.*;
+
+
+public class LineClipTest extends Component implements Runnable {
+
+ int clipBumpVal = 5;
+ static int clipSize = 100;
+ int clipX1;
+ int clipY1;
+ static final int NUM_QUADS = 9;
+ Point quadrants[][] = new Point[NUM_QUADS][];
+ static boolean dynamic = false;
+ BufferedImage imageChecker = null;
+ Color unclippedColor = Color.blue;
+ Color clippedColor = Color.red;
+ int testW = -1, testH = -1;
+ VolatileImage testImage = null;
+ static boolean keepRunning = false;
+ static boolean quickTest = false;
+ static boolean rectTest = false;
+ static boolean runTestDone = false;
+ static Frame f = null;
+
+ /**
+ * Check for errors in the grid. This error check consists of
+ * copying the buffer into a BufferedImage and reading all pixels
+ * in that image. No pixel outside the clip bounds should be
+ * of the color clippedColor and no pixel inside should be
+ * of the color unclippedColor. Any wrong color returns an error.
+ */
+ boolean gridError(Graphics g) {
+ boolean error = false;
+ if (imageChecker == null || (imageChecker.getWidth() != testW) ||
+ (imageChecker.getHeight() != testH))
+ {
+ // Recreate BufferedImage as necessary
+ GraphicsConfiguration gc = getGraphicsConfiguration();
+ ColorModel cm = gc.getColorModel();
+ WritableRaster wr =
+ cm.createCompatibleWritableRaster(getWidth(), getHeight());
+ imageChecker =
+ new BufferedImage(cm, wr,
+ cm.isAlphaPremultiplied(), null);
+ }
+ // Copy buffer to BufferedImage
+ Graphics gChecker = imageChecker.getGraphics();
+ gChecker.drawImage(testImage, 0, 0, this);
+
+ // Set up pixel colors to check against
+ int clippedPixelColor = clippedColor.getRGB();
+ int unclippedPixelColor = unclippedColor.getRGB();
+ int wrongPixelColor = clippedPixelColor;
+ boolean insideClip = false;
+ for (int row = 0; row < getHeight(); ++row) {
+ for (int col = 0; col < getWidth(); ++col) {
+ if (row >= clipY1 && row < (clipY1 + clipSize) &&
+ col >= clipX1 && col < (clipX1 + clipSize))
+ {
+ // Inside clip bounds - should not see unclipped color
+ wrongPixelColor = unclippedPixelColor;
+ } else {
+ // Outside clip - should not see clipped color
+ wrongPixelColor = clippedPixelColor;
+ }
+ int pixel = imageChecker.getRGB(col, row);
+ if (pixel == wrongPixelColor) {
+ System.out.println("FAILED: pixel = " +
+ Integer.toHexString(pixel) +
+ " at (x, y) = " + col + ", " + row);
+ // Draw magenta rectangle around problem pixel in buffer
+ // for visual feedback to user
+ g.setColor(Color.magenta);
+ g.drawRect(col - 1, row - 1, 2, 2);
+ error = true;
+ }
+ }
+ }
+ return error;
+ }
+
+ /**
+ * Draw all test lines and check for errors (unless running
+ * with -dynamic option)
+ */
+ void drawLineGrid(Graphics screenGraphics, Graphics g) {
+ // Fill buffer with background color
+ g.setColor(Color.white);
+ g.fillRect(0, 0, getWidth(), getHeight());
+
+ // Now, iterate through all quadrants
+ for (int srcQuad = 0; srcQuad < NUM_QUADS; ++srcQuad) {
+ // Draw lines to all other quadrants
+ for (int dstQuad = 0; dstQuad < NUM_QUADS; ++dstQuad) {
+ for (int srcPoint = 0;
+ srcPoint < quadrants[srcQuad].length;
+ ++srcPoint)
+ {
+ // For every point in the source quadrant
+ int sx = quadrants[srcQuad][srcPoint].x;
+ int sy = quadrants[srcQuad][srcPoint].y;
+ for (int dstPoint = 0;
+ dstPoint < quadrants[dstQuad].length;
+ ++dstPoint)
+ {
+ int dx = quadrants[dstQuad][dstPoint].x;
+ int dy = quadrants[dstQuad][dstPoint].y;
+ if (!rectTest) {
+ // Draw unclipped/clipped lines to every
+ // point in the dst quadrant
+ g.setColor(unclippedColor);
+ g.drawLine(sx, sy, dx, dy);
+ g.setClip(clipX1, clipY1, clipSize, clipSize);
+ g.setColor(clippedColor);
+ g.drawLine(sx,sy, dx, dy);
+ } else {
+ // Draw unclipped/clipped rectangles to every
+ // point in the dst quadrant
+ g.setColor(unclippedColor);
+ int w = dx - sx;
+ int h = dy - sy;
+ g.drawRect(sx, sy, w, h);
+ g.setClip(clipX1, clipY1, clipSize, clipSize);
+ g.setColor(clippedColor);
+ g.drawRect(sx, sy, w, h);
+ }
+ g.setClip(null);
+ }
+ if (!dynamic) {
+ // Draw screen update for visual feedback
+ screenGraphics.drawImage(testImage, 0, 0, this);
+ // On default test, check for errors after every
+ // src point
+ if (!quickTest && gridError(g)) {
+ throw new java.lang.RuntimeException("Failed");
+ }
+ }
+ }
+ }
+ if (!dynamic && quickTest && gridError(g)) {
+ // On quick test, check for errors only after every
+ // src quadrant
+ throw new java.lang.RuntimeException("Failed");
+ //return;
+ }
+ }
+ if (!dynamic) {
+ System.out.println("PASSED");
+ if (!keepRunning) {
+ f.dispose();
+ }
+ }
+ }
+
+ /**
+ * If we have not yet run the test, or if the window size has
+ * changed, or if we are running the test in -dynamic mode,
+ * run the test. Then draw the test buffer to the screen
+ */
+ public void paint(Graphics g) {
+ if (dynamic || testImage == null ||
+ getWidth() != testW || getHeight() != testH)
+ {
+ runTest(g);
+ }
+ if (testImage != null) {
+ g.drawImage(testImage, 0, 0, this);
+ }
+ }
+
+ /*
+ * Create the quadrant of points and run the test to draw all the lines
+ */
+ public void runTest(Graphics screenGraphics) {
+ if (getWidth() == 0 || getHeight() == 0) {
+ // May get here before window is really ready
+ return;
+ }
+ clipX1 = (getWidth() - clipSize) / 2;
+ clipY1 = (getHeight() - clipSize) / 2;
+ int clipX2 = clipX1 + clipSize;
+ int clipY2 = clipY1 + clipSize;
+ int centerX = getWidth()/2;
+ int centerY = getHeight()/2;
+ int leftX = 0;
+ int topY = 0;
+ int rightX = getWidth() - 1;
+ int bottomY = getHeight() - 1;
+ int quadIndex = 0;
+ // Offsets are used to force diagonal (versus hor/vert) lines
+ int xOffset = 0;
+ int yOffset = 0;
+
+ if (quadrants[0] == null) {
+ for (int i = 0; i < 9; ++i) {
+ int numPoints = (i == 4) ? 9 : 3;
+ quadrants[i] = new Point[numPoints];
+ }
+ }
+ // Upper-left
+ quadrants[quadIndex] = new Point[] {
+ new Point(leftX + xOffset, clipY1 - 1 - yOffset),
+ new Point(leftX + xOffset, topY + yOffset),
+ new Point(clipX1 - 1 - xOffset, topY + yOffset),
+ };
+
+ quadIndex++;
+ yOffset++;
+ // Upper-middle
+ quadrants[quadIndex] = new Point[] {
+ new Point(clipX1 + 1 + xOffset, topY + yOffset),
+ new Point(centerX + xOffset, topY + yOffset),
+ new Point(clipX2 - 1 - xOffset, topY + yOffset),
+ };
+
+ quadIndex++;
+ ++yOffset;
+ // Upper-right
+ quadrants[quadIndex] = new Point[] {
+ new Point(clipX2 + 1 + xOffset, topY + yOffset),
+ new Point(rightX - xOffset, topY + yOffset),
+ new Point(rightX - xOffset, clipY1 - 1 - yOffset),
+ };
+
+ quadIndex++;
+ yOffset = 0;
+ ++xOffset;
+ // Middle-left
+ quadrants[quadIndex] = new Point[] {
+ new Point(leftX + xOffset, clipY1 + 1 + yOffset),
+ new Point(leftX + xOffset, centerY + yOffset),
+ new Point(leftX + xOffset, clipY2 - 1 - yOffset),
+ };
+
+ quadIndex++;
+ ++yOffset;
+ // Middle-middle
+ quadrants[quadIndex] = new Point[] {
+ new Point(clipX1 + 1 + xOffset, clipY1 + 1 + yOffset),
+ new Point(centerX + xOffset, clipY1 + 1 + yOffset),
+ new Point(clipX2 - 1 - xOffset, clipY1 + 1 + yOffset),
+ new Point(clipX1 + 1 + xOffset, centerY + yOffset),
+ new Point(centerX + xOffset, centerY + yOffset),
+ new Point(clipX2 - 1 - xOffset, centerY + yOffset),
+ new Point(clipX1 + 1 + xOffset, clipY2 - 1 - yOffset),
+ new Point(centerX + xOffset, clipY2 - 1 - yOffset),
+ new Point(clipX2 - 1 - xOffset, clipY2 - 1 - yOffset),
+ };
+
+ quadIndex++;
+ ++yOffset;
+ // Middle-right
+ quadrants[quadIndex] = new Point[] {
+ new Point(rightX - xOffset, clipY1 + 1 + yOffset),
+ new Point(rightX - xOffset, centerY + yOffset),
+ new Point(rightX - xOffset, clipY2 - 1 - yOffset),
+ };
+
+ quadIndex++;
+ yOffset = 0;
+ ++xOffset;
+ // Lower-left
+ quadrants[quadIndex] = new Point[] {
+ new Point(leftX + xOffset, clipY2 + 1 + yOffset),
+ new Point(leftX + xOffset, bottomY - yOffset),
+ new Point(clipX1 - 1 - xOffset, bottomY - yOffset),
+ };
+
+ quadIndex++;
+ ++yOffset;
+ // Lower-middle
+ quadrants[quadIndex] = new Point[] {
+ new Point(clipX1 + 1 + xOffset, bottomY - yOffset),
+ new Point(centerX + xOffset, bottomY - yOffset),
+ new Point(clipX2 - 1 - xOffset, bottomY - yOffset),
+ };
+
+ quadIndex++;
+ ++yOffset;
+ // Lower-right
+ quadrants[quadIndex] = new Point[] {
+ new Point(clipX2 + 1 + xOffset, bottomY - yOffset),
+ new Point(rightX - xOffset, bottomY - yOffset),
+ new Point(rightX - xOffset, clipY2 + 1 + yOffset),
+ };
+
+
+ if (testImage != null) {
+ testImage.flush();
+ }
+ testW = getWidth();
+ testH = getHeight();
+ testImage = createVolatileImage(testW, testH);
+ Graphics g = testImage.getGraphics();
+ do {
+ int valCode = testImage.validate(getGraphicsConfiguration());
+ if (valCode == VolatileImage.IMAGE_INCOMPATIBLE) {
+ testImage.flush();
+ testImage = createVolatileImage(testW, testH);
+ g = testImage.getGraphics();
+ }
+ drawLineGrid(screenGraphics, g);
+ } while (testImage.contentsLost());
+ if (dynamic) {
+ // Draw clip box if dynamic
+ g.setClip(null);
+ g.setColor(Color.black);
+ g.drawRect(clipX1, clipY1, clipSize, clipSize);
+ screenGraphics.drawImage(testImage, 0, 0, this);
+ }
+ runTestDone = true;
+ }
+
+ /**
+ * When running -dynamic, resize the clip bounds and run the test
+ * over and over
+ */
+ public void run() {
+ while (true) {
+ clipSize += clipBumpVal;
+ if (clipSize > getWidth() || clipSize < 0) {
+ clipBumpVal = -clipBumpVal;
+ clipSize += clipBumpVal;
+ }
+ update(getGraphics());
+ try {
+ Thread.sleep(50);
+ } catch (Exception e) {}
+ }
+ }
+
+ public static void main(String args[]) {
+ for (int i = 0; i < args.length; ++i) {
+ if (args[i].equals("-dynamic")) {
+ dynamic = true;
+ } else if (args[i].equals("-rect")) {
+ rectTest = true;
+ } else if (args[i].equals("-quick")) {
+ quickTest = true;
+ } else if (args[i].equals("-keep")) {
+ keepRunning = true;
+ } else {
+ // could be clipSize
+ try {
+ clipSize = Integer.parseInt(args[i]);
+ } catch (Exception e) {}
+ }
+ }
+ f = new Frame();
+ f.setSize(500, 500);
+ LineClipTest test = new LineClipTest();
+ f.add(test);
+ if (dynamic) {
+ Thread t = new Thread(test);
+ t.start();
+ }
+ f.setVisible(true);
+ while (!runTestDone) {
+ // need to make sure jtreg doesn't exit before the
+ // test is done...
+ try {
+ Thread.sleep(50);
+ } catch (Exception e) {}
+ }
+ }
+}