--- old/src/java.desktop/share/classes/sun/java2d/pipe/RenderingEngine.java 2015-11-23 13:25:04.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/pipe/RenderingEngine.java 2015-11-23 13:25:04.000000000 -0800
@@ -96,9 +96,14 @@
*
*
* If no specific {@code RenderingEngine} is specified on the command
- * or Ductus renderer is specified, it will first attempt loading the
- * sun.dc.DuctusRenderingEngine class using Class.forName, if that
- * is not found, then it will look for Pisces.
+ * line or the requested class fails to load, then the Marlin
+ * renderer will be used as the default.
+ *
+ * A printout of which RenderingEngine is loaded and used can be
+ * enabled by specifying the runtime flag:
+ *
+ * java -Dsun.java2d.renderer.verbose=true
+ *
*
* Runtime tracing of the actions of the {@code RenderingEngine}
* can be enabled by specifying the runtime flag:
@@ -113,20 +118,23 @@
return reImpl;
}
- /* Look first for ductus or an app-override renderer,
- * if not specified or present, then look for pisces.
+ /* Look first for an app-override renderer,
+ * if not specified or present, then look for marlin.
*/
- final String ductusREClass = "sun.dc.DuctusRenderingEngine";
- final String piscesREClass = "sun.java2d.pisces.PiscesRenderingEngine";
GetPropertyAction gpa =
- new GetPropertyAction("sun.java2d.renderer", ductusREClass);
+ new GetPropertyAction("sun.java2d.renderer");
String reClass = AccessController.doPrivileged(gpa);
- try {
- Class> cls = Class.forName(reClass);
- reImpl = (RenderingEngine) cls.newInstance();
- } catch (ReflectiveOperationException ignored0) {
+ if (reClass != null) {
+ try {
+ Class> cls = Class.forName(reClass);
+ reImpl = (RenderingEngine) cls.newInstance();
+ } catch (ReflectiveOperationException ignored0) {
+ }
+ }
+ if (reImpl == null) {
+ final String marlinREClass = "sun.java2d.marlin.MarlinRenderingEngine";
try {
- Class> cls = Class.forName(piscesREClass);
+ Class> cls = Class.forName(marlinREClass);
reImpl = (RenderingEngine) cls.newInstance();
} catch (ReflectiveOperationException ignored1) {
}
@@ -136,6 +144,12 @@
throw new InternalError("No RenderingEngine module found");
}
+ gpa = new GetPropertyAction("sun.java2d.renderer.verbose");
+ String verbose = AccessController.doPrivileged(gpa);
+ if (verbose != null && verbose.startsWith("t")) {
+ System.out.println("RenderingEngine = "+reImpl);
+ }
+
gpa = new GetPropertyAction("sun.java2d.renderer.trace");
String reTrace = AccessController.doPrivileged(gpa);
if (reTrace != null) {
--- old/src/java.desktop/share/classes/sun/java2d/pipe/AAShapePipe.java 2015-11-23 13:25:05.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/pipe/AAShapePipe.java 2015-11-23 13:25:05.000000000 -0800
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2015, 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
@@ -22,14 +22,12 @@
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
-
package sun.java2d.pipe;
import java.awt.BasicStroke;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.geom.Rectangle2D;
-import java.awt.geom.PathIterator;
import sun.awt.SunHints;
import sun.java2d.SunGraphics2D;
@@ -45,6 +43,15 @@
{
static RenderingEngine renderengine = RenderingEngine.getInstance();
+ // Per-thread TileState (~1K very small so do not use any Weak Reference)
+ private static final ThreadLocal tileStateThreadLocal =
+ new ThreadLocal() {
+ @Override
+ protected TileState initialValue() {
+ return new TileState();
+ }
+ };
+
CompositePipe outpipe;
public AAShapePipe(CompositePipe pipe) {
@@ -68,20 +75,6 @@
renderPath(sg, s, null);
}
- private static Rectangle2D computeBBox(double ux1, double uy1,
- double ux2, double uy2)
- {
- if ((ux2 -= ux1) < 0) {
- ux1 += ux2;
- ux2 = -ux2;
- }
- if ((uy2 -= uy1) < 0) {
- uy1 += uy2;
- uy2 = -uy2;
- }
- return new Rectangle2D.Double(ux1, uy1, ux2, uy2);
- }
-
public void fillParallelogram(SunGraphics2D sg,
double ux1, double uy1,
double ux2, double uy2,
@@ -90,7 +83,9 @@
double dx2, double dy2)
{
Region clip = sg.getCompClip();
- int abox[] = new int[4];
+ final TileState ts = tileStateThreadLocal.get();
+ final int[] abox = ts.abox;
+
AATileGenerator aatg =
renderengine.getAATileGenerator(x, y, dx1, dy1, dx2, dy2, 0, 0,
clip, abox);
@@ -99,7 +94,7 @@
return;
}
- renderTiles(sg, computeBBox(ux1, uy1, ux2, uy2), aatg, abox);
+ renderTiles(sg, ts.computeBBox(ux1, uy1, ux2, uy2), aatg, abox, ts);
}
public void drawParallelogram(SunGraphics2D sg,
@@ -111,7 +106,9 @@
double lw1, double lw2)
{
Region clip = sg.getCompClip();
- int abox[] = new int[4];
+ final TileState ts = tileStateThreadLocal.get();
+ final int[] abox = ts.abox;
+
AATileGenerator aatg =
renderengine.getAATileGenerator(x, y, dx1, dy1, dx2, dy2, lw1, lw2,
clip, abox);
@@ -122,23 +119,7 @@
// Note that bbox is of the original shape, not the wide path.
// This is appropriate for handing to Paint methods...
- renderTiles(sg, computeBBox(ux1, uy1, ux2, uy2), aatg, abox);
- }
-
- private static byte[] theTile;
-
- private static synchronized byte[] getAlphaTile(int len) {
- byte[] t = theTile;
- if (t == null || t.length < len) {
- t = new byte[len];
- } else {
- theTile = null;
- }
- return t;
- }
-
- private static synchronized void dropAlphaTile(byte[] t) {
- theTile = t;
+ renderTiles(sg, ts.computeBBox(ux1, uy1, ux2, uy2), aatg, abox, ts);
}
public void renderPath(SunGraphics2D sg, Shape s, BasicStroke bs) {
@@ -147,7 +128,9 @@
boolean thin = (sg.strokeState <= SunGraphics2D.STROKE_THINDASHED);
Region clip = sg.getCompClip();
- int abox[] = new int[4];
+ final TileState ts = tileStateThreadLocal.get();
+ final int[] abox = ts.abox;
+
AATileGenerator aatg =
renderengine.getAATileGenerator(s, sg.transform, clip,
bs, thin, adjust, abox);
@@ -156,31 +139,30 @@
return;
}
- renderTiles(sg, s, aatg, abox);
+ renderTiles(sg, s, aatg, abox, ts);
}
public void renderTiles(SunGraphics2D sg, Shape s,
- AATileGenerator aatg, int abox[])
+ AATileGenerator aatg, int abox[], TileState ts)
{
Object context = null;
- byte alpha[] = null;
try {
context = outpipe.startSequence(sg, s,
- new Rectangle(abox[0], abox[1],
- abox[2] - abox[0],
- abox[3] - abox[1]),
+ ts.computeDevBox(abox),
abox);
- int tw = aatg.getTileWidth();
- int th = aatg.getTileHeight();
- alpha = getAlphaTile(tw * th);
+ final int tw = aatg.getTileWidth();
+ final int th = aatg.getTileHeight();
+ // get tile from thread local storage:
+ final byte[] alpha = ts.getAlphaTile(tw * th);
byte[] atile;
for (int y = abox[1]; y < abox[3]; y += th) {
+ int h = Math.min(th, abox[3] - y);
+
for (int x = abox[0]; x < abox[2]; x += tw) {
int w = Math.min(tw, abox[2] - x);
- int h = Math.min(th, abox[3] - y);
int a = aatg.getTypicalAlpha();
if (a == 0x00 ||
@@ -207,9 +189,56 @@
if (context != null) {
outpipe.endSequence(context);
}
- if (alpha != null) {
- dropAlphaTile(alpha);
+ }
+ }
+
+ // Tile state used by AAShapePipe
+ static final class TileState {
+ // cached tile (32 x 32 tile by default)
+ private byte[] theTile = new byte[32 * 32];
+ // dirty aabox array
+ final int[] abox = new int[4];
+ // dirty bbox rectangle
+ private final Rectangle dev = new Rectangle();
+ // dirty bbox rectangle2D.Double
+ private final Rectangle2D.Double bbox2D = new Rectangle2D.Double();
+
+ byte[] getAlphaTile(int len) {
+ byte[] t = theTile;
+ if (t.length < len) {
+ // create a larger tile and may free current theTile (too small)
+ theTile = t = new byte[len];
+ }
+ return t;
+ }
+
+ Rectangle computeDevBox(final int[] abox) {
+ final Rectangle box = this.dev;
+ box.x = abox[0];
+ box.y = abox[1];
+ box.width = abox[2] - abox[0];
+ box.height = abox[3] - abox[1];
+ return box;
+ }
+
+ Rectangle2D computeBBox(double ux1, double uy1,
+ double ux2, double uy2)
+ {
+ if ((ux2 -= ux1) < 0.0) {
+ ux1 += ux2;
+ ux2 = -ux2;
+ }
+ if ((uy2 -= uy1) < 0.0) {
+ uy1 += uy2;
+ uy2 = -uy2;
}
+ final Rectangle2D.Double box = this.bbox2D;
+ box.x = ux1;
+ box.y = uy1;
+ box.width = ux2;
+ box.height = uy2;
+ return box;
}
}
+
}
--- /dev/null 2015-11-23 13:25:07.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/marlin/ArrayCache.java 2015-11-23 13:25:06.000000000 -0800
@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2015, 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.
+ */
+
+package sun.java2d.marlin;
+
+import java.util.Arrays;
+import static sun.java2d.marlin.MarlinUtils.logInfo;
+
+public final class ArrayCache implements MarlinConst {
+
+ static final int BUCKETS = 4;
+ static final int MIN_ARRAY_SIZE = 4096;
+ static final int MAX_ARRAY_SIZE;
+ static final int MASK_CLR_1 = ~1;
+ // threshold to grow arrays only by (3/2) instead of 2
+ static final int THRESHOLD_ARRAY_SIZE;
+ static final int[] ARRAY_SIZES = new int[BUCKETS];
+ // dirty byte array sizes
+ static final int MIN_DIRTY_BYTE_ARRAY_SIZE = 32 * 2048; // 32px x 2048px
+ static final int MAX_DIRTY_BYTE_ARRAY_SIZE;
+ static final int[] DIRTY_BYTE_ARRAY_SIZES = new int[BUCKETS];
+ // large array thresholds:
+ static final long THRESHOLD_LARGE_ARRAY_SIZE;
+ static final long THRESHOLD_HUGE_ARRAY_SIZE;
+ // stats
+ private static int resizeInt = 0;
+ private static int resizeDirtyInt = 0;
+ private static int resizeDirtyFloat = 0;
+ private static int resizeDirtyByte = 0;
+ private static int oversize = 0;
+
+ static {
+ // initialize buckets for int/float arrays
+ int arraySize = MIN_ARRAY_SIZE;
+
+ for (int i = 0; i < BUCKETS; i++, arraySize <<= 2) {
+ ARRAY_SIZES[i] = arraySize;
+
+ if (doTrace) {
+ logInfo("arraySize[" + i + "]: " + arraySize);
+ }
+ }
+ MAX_ARRAY_SIZE = arraySize >> 2;
+
+ /* initialize buckets for dirty byte arrays
+ (large AA chunk = 32 x 2048 pixels) */
+ arraySize = MIN_DIRTY_BYTE_ARRAY_SIZE;
+
+ for (int i = 0; i < BUCKETS; i++, arraySize <<= 1) {
+ DIRTY_BYTE_ARRAY_SIZES[i] = arraySize;
+
+ if (doTrace) {
+ logInfo("dirty arraySize[" + i + "]: " + arraySize);
+ }
+ }
+ MAX_DIRTY_BYTE_ARRAY_SIZE = arraySize >> 1;
+
+ // threshold to grow arrays only by (3/2) instead of 2
+ THRESHOLD_ARRAY_SIZE = Math.max(2 * 1024 * 1024, MAX_ARRAY_SIZE); // 2M
+
+ THRESHOLD_LARGE_ARRAY_SIZE = 8L * THRESHOLD_ARRAY_SIZE; // 16M
+ THRESHOLD_HUGE_ARRAY_SIZE = 8L * THRESHOLD_LARGE_ARRAY_SIZE; // 128M
+
+ if (doStats || doMonitors) {
+ logInfo("ArrayCache.BUCKETS = " + BUCKETS);
+ logInfo("ArrayCache.MIN_ARRAY_SIZE = " + MIN_ARRAY_SIZE);
+ logInfo("ArrayCache.MAX_ARRAY_SIZE = " + MAX_ARRAY_SIZE);
+ logInfo("ArrayCache.ARRAY_SIZES = "
+ + Arrays.toString(ARRAY_SIZES));
+ logInfo("ArrayCache.MIN_DIRTY_BYTE_ARRAY_SIZE = "
+ + MIN_DIRTY_BYTE_ARRAY_SIZE);
+ logInfo("ArrayCache.MAX_DIRTY_BYTE_ARRAY_SIZE = "
+ + MAX_DIRTY_BYTE_ARRAY_SIZE);
+ logInfo("ArrayCache.ARRAY_SIZES = "
+ + Arrays.toString(DIRTY_BYTE_ARRAY_SIZES));
+ logInfo("ArrayCache.THRESHOLD_ARRAY_SIZE = "
+ + THRESHOLD_ARRAY_SIZE);
+ logInfo("ArrayCache.THRESHOLD_LARGE_ARRAY_SIZE = "
+ + THRESHOLD_LARGE_ARRAY_SIZE);
+ logInfo("ArrayCache.THRESHOLD_HUGE_ARRAY_SIZE = "
+ + THRESHOLD_HUGE_ARRAY_SIZE);
+ }
+ }
+
+ private ArrayCache() {
+ // Utility class
+ }
+
+ static synchronized void incResizeInt() {
+ resizeInt++;
+ }
+
+ static synchronized void incResizeDirtyInt() {
+ resizeDirtyInt++;
+ }
+
+ static synchronized void incResizeDirtyFloat() {
+ resizeDirtyFloat++;
+ }
+
+ static synchronized void incResizeDirtyByte() {
+ resizeDirtyByte++;
+ }
+
+ static synchronized void incOversize() {
+ oversize++;
+ }
+
+ static void dumpStats() {
+ if (resizeInt != 0 || resizeDirtyInt != 0 || resizeDirtyFloat != 0
+ || resizeDirtyByte != 0 || oversize != 0) {
+ logInfo("ArrayCache: int resize: " + resizeInt
+ + " - dirty int resize: " + resizeDirtyInt
+ + " - dirty float resize: " + resizeDirtyFloat
+ + " - dirty byte resize: " + resizeDirtyByte
+ + " - oversize: " + oversize);
+ }
+ }
+
+ // small methods used a lot (to be inlined / optimized by hotspot)
+
+ static int getBucket(final int length) {
+ for (int i = 0; i < ARRAY_SIZES.length; i++) {
+ if (length <= ARRAY_SIZES[i]) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ static int getBucketDirtyBytes(final int length) {
+ for (int i = 0; i < DIRTY_BYTE_ARRAY_SIZES.length; i++) {
+ if (length <= DIRTY_BYTE_ARRAY_SIZES[i]) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * Return the new array size (~ x2)
+ * @param curSize current used size
+ * @param needSize needed size
+ * @return new array size
+ */
+ public static int getNewSize(final int curSize, final int needSize) {
+ final int initial = (curSize & MASK_CLR_1);
+ int size;
+ if (initial > THRESHOLD_ARRAY_SIZE) {
+ size = initial + (initial >> 1); // x(3/2)
+ } else {
+ size = (initial) << 1; // x2
+ }
+ // ensure the new size is >= needed size:
+ if (size < needSize) {
+ // align to 4096:
+ size = ((needSize >> 12) + 1) << 12;
+ }
+ return size;
+ }
+
+ /**
+ * Return the new array size (~ x2)
+ * @param curSize current used size
+ * @param needSize needed size
+ * @return new array size
+ */
+ public static long getNewLargeSize(final long curSize, final long needSize) {
+ long size;
+ if (curSize > THRESHOLD_HUGE_ARRAY_SIZE) {
+ size = curSize + (curSize >> 2L); // x(5/4)
+ } else if (curSize > THRESHOLD_LARGE_ARRAY_SIZE) {
+ size = curSize + (curSize >> 1L); // x(3/2)
+ } else {
+ size = curSize << 1L; // x2
+ }
+ // ensure the new size is >= needed size:
+ if (size < needSize) {
+ // align to 4096:
+ size = ((needSize >> 12) + 1) << 12;
+ }
+ if (size >= Integer.MAX_VALUE) {
+ if (curSize >= Integer.MAX_VALUE) {
+ // hard overflow failure - we can't even accommodate
+ // new items without overflowing
+ throw new ArrayIndexOutOfBoundsException(
+ "array exceeds maximum capacity !");
+ }
+ // resize to maximum capacity:
+ size = Integer.MAX_VALUE;
+ }
+ return size;
+ }
+}
--- /dev/null 2015-11-23 13:25:07.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/marlin/ByteArrayCache.java 2015-11-23 13:25:07.000000000 -0800
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2015, 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.
+ */
+
+package sun.java2d.marlin;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import static sun.java2d.marlin.MarlinUtils.logException;
+import static sun.java2d.marlin.MarlinUtils.logInfo;
+
+final class ByteArrayCache implements MarlinConst {
+
+ private final int arraySize;
+ private final ArrayDeque byteArrays;
+ // stats
+ private int getOp = 0;
+ private int createOp = 0;
+ private int returnOp = 0;
+
+ void dumpStats() {
+ if (getOp > 0) {
+ logInfo("ByteArrayCache[" + arraySize + "]: get: " + getOp
+ + " created: " + createOp + " - returned: " + returnOp
+ + " :: cache size: " + byteArrays.size());
+ }
+ }
+
+ ByteArrayCache(final int arraySize) {
+ this.arraySize = arraySize;
+ // small but enough: almost 1 cache line
+ this.byteArrays = new ArrayDeque(6);
+ }
+
+ byte[] getArray() {
+ if (doStats) {
+ getOp++;
+ }
+
+ // use cache:
+ final byte[] array = byteArrays.pollLast();
+ if (array != null) {
+ return array;
+ }
+
+ if (doStats) {
+ createOp++;
+ }
+
+ return new byte[arraySize];
+ }
+
+ void putDirtyArray(final byte[] array, final int length) {
+ if (length != arraySize) {
+ if (doChecks) {
+ System.out.println("ArrayCache: bad length = " + length);
+ }
+ return;
+ }
+ if (doStats) {
+ returnOp++;
+ }
+
+ // NO clean-up of array data = DIRTY ARRAY
+
+ if (doCleanDirty) {
+ // Force zero-fill dirty arrays:
+ Arrays.fill(array, 0, array.length, BYTE_0);
+ }
+
+ // fill cache:
+ byteArrays.addLast(array);
+ }
+
+ void putArray(final byte[] array, final int length,
+ final int fromIndex, final int toIndex)
+ {
+ if (length != arraySize) {
+ if (doChecks) {
+ System.out.println("ArrayCache: bad length = " + length);
+ }
+ return;
+ }
+ if (doStats) {
+ returnOp++;
+ }
+
+ // clean-up array of dirty part[fromIndex; toIndex[
+ fill(array, fromIndex, toIndex, BYTE_0);
+
+ // fill cache:
+ byteArrays.addLast(array);
+ }
+
+ static void fill(final byte[] array, final int fromIndex,
+ final int toIndex, final byte value)
+ {
+ // clear array data:
+ /*
+ * Arrays.fill is faster than System.arraycopy(empty array)
+ * or Unsafe.setMemory(byte 0)
+ */
+ if (toIndex != 0) {
+ Arrays.fill(array, fromIndex, toIndex, value);
+ }
+
+ if (doChecks) {
+ check(array, 0, array.length, value);
+ }
+ }
+
+ static void check(final byte[] array, final int fromIndex,
+ final int toIndex, final byte value)
+ {
+ if (doChecks) {
+ // check zero on full array:
+ for (int i = fromIndex; i < toIndex; i++) {
+ if (array[i] != value) {
+ logException("Invalid array value at " + i + "\n"
+ + Arrays.toString(array), new Throwable());
+
+ // ensure array is correctly filled:
+ Arrays.fill(array, value);
+
+ return;
+ }
+ }
+ }
+ }
+}
--- /dev/null 2015-11-23 13:25:08.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/marlin/CollinearSimplifier.java 2015-11-23 13:25:08.000000000 -0800
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2015, 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.
+ */
+
+package sun.java2d.marlin;
+
+import sun.awt.geom.PathConsumer2D;
+
+final class CollinearSimplifier implements PathConsumer2D {
+
+ enum SimplifierState {
+
+ Empty, PreviousPoint, PreviousLine
+ };
+ // slope precision threshold
+ static final float EPS = 1e-4f; // aaime proposed 1e-3f
+
+ PathConsumer2D delegate;
+ SimplifierState state;
+ float px1, py1, px2, py2;
+ float pslope;
+
+ CollinearSimplifier() {
+ }
+
+ public CollinearSimplifier init(PathConsumer2D delegate) {
+ this.delegate = delegate;
+ this.state = SimplifierState.Empty;
+
+ return this; // fluent API
+ }
+
+ @Override
+ public void pathDone() {
+ emitStashedLine();
+ state = SimplifierState.Empty;
+ delegate.pathDone();
+ }
+
+ @Override
+ public void closePath() {
+ emitStashedLine();
+ state = SimplifierState.Empty;
+ delegate.closePath();
+ }
+
+ @Override
+ public long getNativeConsumer() {
+ return 0;
+ }
+
+ @Override
+ public void quadTo(float x1, float y1, float x2, float y2) {
+ emitStashedLine();
+ delegate.quadTo(x1, y1, x2, y2);
+ // final end point:
+ state = SimplifierState.PreviousPoint;
+ px1 = x2;
+ py1 = y2;
+ }
+
+ @Override
+ public void curveTo(float x1, float y1, float x2, float y2,
+ float x3, float y3) {
+ emitStashedLine();
+ delegate.curveTo(x1, y1, x2, y2, x3, y3);
+ // final end point:
+ state = SimplifierState.PreviousPoint;
+ px1 = x3;
+ py1 = y3;
+ }
+
+ @Override
+ public void moveTo(float x, float y) {
+ emitStashedLine();
+ delegate.moveTo(x, y);
+ state = SimplifierState.PreviousPoint;
+ px1 = x;
+ py1 = y;
+ }
+
+ @Override
+ public void lineTo(final float x, final float y) {
+ switch (state) {
+ case Empty:
+ delegate.lineTo(x, y);
+ state = SimplifierState.PreviousPoint;
+ px1 = x;
+ py1 = y;
+ return;
+
+ case PreviousPoint:
+ state = SimplifierState.PreviousLine;
+ px2 = x;
+ py2 = y;
+ pslope = getSlope(px1, py1, x, y);
+ return;
+
+ case PreviousLine:
+ final float slope = getSlope(px2, py2, x, y);
+ // test for collinearity
+ if ((slope == pslope) || (Math.abs(pslope - slope) < EPS)) {
+ // merge segments
+ px2 = x;
+ py2 = y;
+ return;
+ }
+ // emit previous segment
+ delegate.lineTo(px2, py2);
+ px1 = px2;
+ py1 = py2;
+ px2 = x;
+ py2 = y;
+ pslope = slope;
+ return;
+ default:
+ }
+ }
+
+ private void emitStashedLine() {
+ if (state == SimplifierState.PreviousLine) {
+ delegate.lineTo(px2, py2);
+ }
+ }
+
+ private static float getSlope(float x1, float y1, float x2, float y2) {
+ float dy = y2 - y1;
+ if (dy == 0f) {
+ return (x2 > x1) ? Float.POSITIVE_INFINITY
+ : Float.NEGATIVE_INFINITY;
+ }
+ return (x2 - x1) / dy;
+ }
+}
--- /dev/null 2015-11-23 13:25:09.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/marlin/Curve.java 2015-11-23 13:25:09.000000000 -0800
@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) 2007, 2015, 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.
+ */
+
+package sun.java2d.marlin;
+
+import java.util.Iterator;
+
+final class Curve {
+
+ float ax, ay, bx, by, cx, cy, dx, dy;
+ float dax, day, dbx, dby;
+ // shared iterator instance
+ private final BreakPtrIterator iterator = new BreakPtrIterator();
+
+ Curve() {
+ }
+
+ void set(float[] points, int type) {
+ switch(type) {
+ case 8:
+ set(points[0], points[1],
+ points[2], points[3],
+ points[4], points[5],
+ points[6], points[7]);
+ return;
+ case 6:
+ set(points[0], points[1],
+ points[2], points[3],
+ points[4], points[5]);
+ return;
+ default:
+ throw new InternalError("Curves can only be cubic or quadratic");
+ }
+ }
+
+ void set(float x1, float y1,
+ float x2, float y2,
+ float x3, float y3,
+ float x4, float y4)
+ {
+ ax = 3f * (x2 - x3) + x4 - x1;
+ ay = 3f * (y2 - y3) + y4 - y1;
+ bx = 3f * (x1 - 2f * x2 + x3);
+ by = 3f * (y1 - 2f * y2 + y3);
+ cx = 3f * (x2 - x1);
+ cy = 3f * (y2 - y1);
+ dx = x1;
+ dy = y1;
+ dax = 3f * ax; day = 3f * ay;
+ dbx = 2f * bx; dby = 2f * by;
+ }
+
+ void set(float x1, float y1,
+ float x2, float y2,
+ float x3, float y3)
+ {
+ ax = 0f; ay = 0f;
+ bx = x1 - 2f * x2 + x3;
+ by = y1 - 2f * y2 + y3;
+ cx = 2f * (x2 - x1);
+ cy = 2f * (y2 - y1);
+ dx = x1;
+ dy = y1;
+ dax = 0f; day = 0f;
+ dbx = 2f * bx; dby = 2f * by;
+ }
+
+ float xat(float t) {
+ return t * (t * (t * ax + bx) + cx) + dx;
+ }
+ float yat(float t) {
+ return t * (t * (t * ay + by) + cy) + dy;
+ }
+
+ float dxat(float t) {
+ return t * (t * dax + dbx) + cx;
+ }
+
+ float dyat(float t) {
+ return t * (t * day + dby) + cy;
+ }
+
+ int dxRoots(float[] roots, int off) {
+ return Helpers.quadraticRoots(dax, dbx, cx, roots, off);
+ }
+
+ int dyRoots(float[] roots, int off) {
+ return Helpers.quadraticRoots(day, dby, cy, roots, off);
+ }
+
+ int infPoints(float[] pts, int off) {
+ // inflection point at t if -f'(t)x*f''(t)y + f'(t)y*f''(t)x == 0
+ // Fortunately, this turns out to be quadratic, so there are at
+ // most 2 inflection points.
+ final float a = dax * dby - dbx * day;
+ final float b = 2f * (cy * dax - day * cx);
+ final float c = cy * dbx - cx * dby;
+
+ return Helpers.quadraticRoots(a, b, c, pts, off);
+ }
+
+ // finds points where the first and second derivative are
+ // perpendicular. This happens when g(t) = f'(t)*f''(t) == 0 (where
+ // * is a dot product). Unfortunately, we have to solve a cubic.
+ private int perpendiculardfddf(float[] pts, int off) {
+ assert pts.length >= off + 4;
+
+ // these are the coefficients of some multiple of g(t) (not g(t),
+ // because the roots of a polynomial are not changed after multiplication
+ // by a constant, and this way we save a few multiplications).
+ final float a = 2f * (dax*dax + day*day);
+ final float b = 3f * (dax*dbx + day*dby);
+ final float c = 2f * (dax*cx + day*cy) + dbx*dbx + dby*dby;
+ final float d = dbx*cx + dby*cy;
+ return Helpers.cubicRootsInAB(a, b, c, d, pts, off, 0f, 1f);
+ }
+
+ // Tries to find the roots of the function ROC(t)-w in [0, 1). It uses
+ // a variant of the false position algorithm to find the roots. False
+ // position requires that 2 initial values x0,x1 be given, and that the
+ // function must have opposite signs at those values. To find such
+ // values, we need the local extrema of the ROC function, for which we
+ // need the roots of its derivative; however, it's harder to find the
+ // roots of the derivative in this case than it is to find the roots
+ // of the original function. So, we find all points where this curve's
+ // first and second derivative are perpendicular, and we pretend these
+ // are our local extrema. There are at most 3 of these, so we will check
+ // at most 4 sub-intervals of (0,1). ROC has asymptotes at inflection
+ // points, so roc-w can have at least 6 roots. This shouldn't be a
+ // problem for what we're trying to do (draw a nice looking curve).
+ int rootsOfROCMinusW(float[] roots, int off, final float w, final float err) {
+ // no OOB exception, because by now off<=6, and roots.length >= 10
+ assert off <= 6 && roots.length >= 10;
+ int ret = off;
+ int numPerpdfddf = perpendiculardfddf(roots, off);
+ float t0 = 0, ft0 = ROCsq(t0) - w*w;
+ roots[off + numPerpdfddf] = 1f; // always check interval end points
+ numPerpdfddf++;
+ for (int i = off; i < off + numPerpdfddf; i++) {
+ float t1 = roots[i], ft1 = ROCsq(t1) - w*w;
+ if (ft0 == 0f) {
+ roots[ret++] = t0;
+ } else if (ft1 * ft0 < 0f) { // have opposite signs
+ // (ROC(t)^2 == w^2) == (ROC(t) == w) is true because
+ // ROC(t) >= 0 for all t.
+ roots[ret++] = falsePositionROCsqMinusX(t0, t1, w*w, err);
+ }
+ t0 = t1;
+ ft0 = ft1;
+ }
+
+ return ret - off;
+ }
+
+ private static float eliminateInf(float x) {
+ return (x == Float.POSITIVE_INFINITY ? Float.MAX_VALUE :
+ (x == Float.NEGATIVE_INFINITY ? Float.MIN_VALUE : x));
+ }
+
+ // A slight modification of the false position algorithm on wikipedia.
+ // This only works for the ROCsq-x functions. It might be nice to have
+ // the function as an argument, but that would be awkward in java6.
+ // TODO: It is something to consider for java8 (or whenever lambda
+ // expressions make it into the language), depending on how closures
+ // and turn out. Same goes for the newton's method
+ // algorithm in Helpers.java
+ private float falsePositionROCsqMinusX(float x0, float x1,
+ final float x, final float err)
+ {
+ final int iterLimit = 100;
+ int side = 0;
+ float t = x1, ft = eliminateInf(ROCsq(t) - x);
+ float s = x0, fs = eliminateInf(ROCsq(s) - x);
+ float r = s, fr;
+ for (int i = 0; i < iterLimit && Math.abs(t - s) > err * Math.abs(t + s); i++) {
+ r = (fs * t - ft * s) / (fs - ft);
+ fr = ROCsq(r) - x;
+ if (sameSign(fr, ft)) {
+ ft = fr; t = r;
+ if (side < 0) {
+ fs /= (1 << (-side));
+ side--;
+ } else {
+ side = -1;
+ }
+ } else if (fr * fs > 0) {
+ fs = fr; s = r;
+ if (side > 0) {
+ ft /= (1 << side);
+ side++;
+ } else {
+ side = 1;
+ }
+ } else {
+ break;
+ }
+ }
+ return r;
+ }
+
+ private static boolean sameSign(float x, float y) {
+ // another way is to test if x*y > 0. This is bad for small x, y.
+ return (x < 0f && y < 0f) || (x > 0f && y > 0f);
+ }
+
+ // returns the radius of curvature squared at t of this curve
+ // see http://en.wikipedia.org/wiki/Radius_of_curvature_(applications)
+ private float ROCsq(final float t) {
+ // dx=xat(t) and dy=yat(t). These calls have been inlined for efficiency
+ final float dx = t * (t * dax + dbx) + cx;
+ final float dy = t * (t * day + dby) + cy;
+ final float ddx = 2f * dax * t + dbx;
+ final float ddy = 2f * day * t + dby;
+ final float dx2dy2 = dx*dx + dy*dy;
+ final float ddx2ddy2 = ddx*ddx + ddy*ddy;
+ final float ddxdxddydy = ddx*dx + ddy*dy;
+ return dx2dy2*((dx2dy2*dx2dy2) / (dx2dy2 * ddx2ddy2 - ddxdxddydy*ddxdxddydy));
+ }
+
+ // curve to be broken should be in pts
+ // this will change the contents of pts but not Ts
+ // TODO: There's no reason for Ts to be an array. All we need is a sequence
+ // of t values at which to subdivide. An array statisfies this condition,
+ // but is unnecessarily restrictive. Ts should be an Iterator instead.
+ // Doing this will also make dashing easier, since we could easily make
+ // LengthIterator an Iterator and feed it to this function to simplify
+ // the loop in Dasher.somethingTo.
+ BreakPtrIterator breakPtsAtTs(final float[] pts, final int type,
+ final float[] Ts, final int numTs)
+ {
+ assert pts.length >= 2*type && numTs <= Ts.length;
+
+ // initialize shared iterator:
+ iterator.init(pts, type, Ts, numTs);
+
+ return iterator;
+ }
+
+ static final class BreakPtrIterator {
+ private int nextCurveIdx;
+ private int curCurveOff;
+ private float prevT;
+ private float[] pts;
+ private int type;
+ private float[] ts;
+ private int numTs;
+
+ void init(final float[] pts, final int type,
+ final float[] ts, final int numTs) {
+ this.pts = pts;
+ this.type = type;
+ this.ts = ts;
+ this.numTs = numTs;
+
+ nextCurveIdx = 0;
+ curCurveOff = 0;
+ prevT = 0f;
+ }
+
+ public boolean hasNext() {
+ return nextCurveIdx <= numTs;
+ }
+
+ public int next() {
+ int ret;
+ if (nextCurveIdx < numTs) {
+ float curT = ts[nextCurveIdx];
+ float splitT = (curT - prevT) / (1f - prevT);
+ Helpers.subdivideAt(splitT,
+ pts, curCurveOff,
+ pts, 0,
+ pts, type, type);
+ prevT = curT;
+ ret = 0;
+ curCurveOff = type;
+ } else {
+ ret = curCurveOff;
+ }
+ nextCurveIdx++;
+ return ret;
+ }
+ }
+}
+
--- /dev/null 2015-11-23 13:25:10.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/marlin/Dasher.java 2015-11-23 13:25:10.000000000 -0800
@@ -0,0 +1,702 @@
+/*
+ * Copyright (c) 2007, 2015, 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.
+ */
+
+package sun.java2d.marlin;
+
+import java.util.Arrays;
+import sun.awt.geom.PathConsumer2D;
+
+/**
+ * The Dasher class takes a series of linear commands
+ * (moveTo, lineTo, close and
+ * end) and breaks them into smaller segments according to a
+ * dash pattern array and a starting dash phase.
+ *
+ *
Issues: in J2Se, a zero length dash segment as drawn as a very
+ * short dash, whereas Pisces does not draw anything. The PostScript
+ * semantics are unclear.
+ *
+ */
+final class Dasher implements sun.awt.geom.PathConsumer2D, MarlinConst {
+
+ static final int recLimit = 4;
+ static final float ERR = 0.01f;
+ static final float minTincrement = 1f / (1 << recLimit);
+
+ private PathConsumer2D out;
+ private float[] dash;
+ private int dashLen;
+ private float startPhase;
+ private boolean startDashOn;
+ private int startIdx;
+
+ private boolean starting;
+ private boolean needsMoveTo;
+
+ private int idx;
+ private boolean dashOn;
+ private float phase;
+
+ private float sx, sy;
+ private float x0, y0;
+
+ // temporary storage for the current curve
+ private final float[] curCurvepts;
+
+ // per-thread renderer context
+ final RendererContext rdrCtx;
+
+ // dashes array (dirty)
+ final float[] dashes_initial = new float[INITIAL_ARRAY];
+
+ // flag to recycle dash array copy
+ boolean recycleDashes;
+
+ // per-thread initial arrays (large enough to satisfy most usages
+ // +1 to avoid recycling in Helpers.widenArray()
+ private final float[] firstSegmentsBuffer_initial = new float[INITIAL_ARRAY + 1];
+
+ /**
+ * Constructs a Dasher.
+ * @param rdrCtx per-thread renderer context
+ */
+ Dasher(final RendererContext rdrCtx) {
+ this.rdrCtx = rdrCtx;
+
+ firstSegmentsBuffer = firstSegmentsBuffer_initial;
+
+ // we need curCurvepts to be able to contain 2 curves because when
+ // dashing curves, we need to subdivide it
+ curCurvepts = new float[8 * 2];
+ }
+
+ /**
+ * Initialize the Dasher.
+ *
+ * @param out an output PathConsumer2D.
+ * @param dash an array of floats containing the dash pattern
+ * @param dashLen length of the given dash array
+ * @param phase a float containing the dash phase
+ * @param recycleDashes true to indicate to recycle the given dash array
+ * @return this instance
+ */
+ Dasher init(final PathConsumer2D out, float[] dash, int dashLen,
+ float phase, boolean recycleDashes)
+ {
+ if (phase < 0f) {
+ throw new IllegalArgumentException("phase < 0 !");
+ }
+ this.out = out;
+
+ // Normalize so 0 <= phase < dash[0]
+ int idx = 0;
+ dashOn = true;
+ float d;
+ while (phase >= (d = dash[idx])) {
+ phase -= d;
+ idx = (idx + 1) % dashLen;
+ dashOn = !dashOn;
+ }
+
+ this.dash = dash;
+ this.dashLen = dashLen;
+ this.startPhase = this.phase = phase;
+ this.startDashOn = dashOn;
+ this.startIdx = idx;
+ this.starting = true;
+ needsMoveTo = false;
+ firstSegidx = 0;
+
+ this.recycleDashes = recycleDashes;
+
+ return this; // fluent API
+ }
+
+ /**
+ * Disposes this dasher:
+ * clean up before reusing this instance
+ */
+ void dispose() {
+ if (doCleanDirty) {
+ // Force zero-fill dirty arrays:
+ Arrays.fill(curCurvepts, 0f);
+ Arrays.fill(firstSegmentsBuffer, 0f);
+ }
+ // Return arrays:
+ if (recycleDashes && dash != dashes_initial) {
+ rdrCtx.putDirtyFloatArray(dash);
+ dash = null;
+ }
+
+ if (firstSegmentsBuffer != firstSegmentsBuffer_initial) {
+ rdrCtx.putDirtyFloatArray(firstSegmentsBuffer);
+ firstSegmentsBuffer = firstSegmentsBuffer_initial;
+ }
+ }
+
+ @Override
+ public void moveTo(float x0, float y0) {
+ if (firstSegidx > 0) {
+ out.moveTo(sx, sy);
+ emitFirstSegments();
+ }
+ needsMoveTo = true;
+ this.idx = startIdx;
+ this.dashOn = this.startDashOn;
+ this.phase = this.startPhase;
+ this.sx = this.x0 = x0;
+ this.sy = this.y0 = y0;
+ this.starting = true;
+ }
+
+ private void emitSeg(float[] buf, int off, int type) {
+ switch (type) {
+ case 8:
+ out.curveTo(buf[off+0], buf[off+1],
+ buf[off+2], buf[off+3],
+ buf[off+4], buf[off+5]);
+ return;
+ case 6:
+ out.quadTo(buf[off+0], buf[off+1],
+ buf[off+2], buf[off+3]);
+ return;
+ case 4:
+ out.lineTo(buf[off], buf[off+1]);
+ return;
+ default:
+ }
+ }
+
+ private void emitFirstSegments() {
+ final float[] fSegBuf = firstSegmentsBuffer;
+
+ for (int i = 0; i < firstSegidx; ) {
+ int type = (int)fSegBuf[i];
+ emitSeg(fSegBuf, i + 1, type);
+ i += (type - 1);
+ }
+ firstSegidx = 0;
+ }
+ // We don't emit the first dash right away. If we did, caps would be
+ // drawn on it, but we need joins to be drawn if there's a closePath()
+ // So, we store the path elements that make up the first dash in the
+ // buffer below.
+ private float[] firstSegmentsBuffer; // dynamic array
+ private int firstSegidx;
+
+ // precondition: pts must be in relative coordinates (relative to x0,y0)
+ // fullCurve is true iff the curve in pts has not been split.
+ private void goTo(float[] pts, int off, final int type) {
+ float x = pts[off + type - 4];
+ float y = pts[off + type - 3];
+ if (dashOn) {
+ if (starting) {
+ int len = type - 2 + 1;
+ int segIdx = firstSegidx;
+ float[] buf = firstSegmentsBuffer;
+ if (segIdx + len > buf.length) {
+ if (doStats) {
+ RendererContext.stats.stat_array_dasher_firstSegmentsBuffer
+ .add(segIdx + len);
+ }
+ firstSegmentsBuffer = buf
+ = rdrCtx.widenDirtyFloatArray(buf, segIdx, segIdx + len);
+ }
+ buf[segIdx++] = type;
+ len--;
+ // small arraycopy (2, 4 or 6) but with offset:
+ System.arraycopy(pts, off, buf, segIdx, len);
+ segIdx += len;
+ firstSegidx = segIdx;
+ } else {
+ if (needsMoveTo) {
+ out.moveTo(x0, y0);
+ needsMoveTo = false;
+ }
+ emitSeg(pts, off, type);
+ }
+ } else {
+ starting = false;
+ needsMoveTo = true;
+ }
+ this.x0 = x;
+ this.y0 = y;
+ }
+
+ @Override
+ public void lineTo(float x1, float y1) {
+ float dx = x1 - x0;
+ float dy = y1 - y0;
+
+ float len = dx*dx + dy*dy;
+ if (len == 0f) {
+ return;
+ }
+ len = (float) Math.sqrt(len);
+
+ // The scaling factors needed to get the dx and dy of the
+ // transformed dash segments.
+ final float cx = dx / len;
+ final float cy = dy / len;
+
+ final float[] _curCurvepts = curCurvepts;
+ final float[] _dash = dash;
+
+ float leftInThisDashSegment;
+ float dashdx, dashdy, p;
+
+ while (true) {
+ leftInThisDashSegment = _dash[idx] - phase;
+
+ if (len <= leftInThisDashSegment) {
+ _curCurvepts[0] = x1;
+ _curCurvepts[1] = y1;
+ goTo(_curCurvepts, 0, 4);
+
+ // Advance phase within current dash segment
+ phase += len;
+ // TODO: compare float values using epsilon:
+ if (len == leftInThisDashSegment) {
+ phase = 0f;
+ idx = (idx + 1) % dashLen;
+ dashOn = !dashOn;
+ }
+ return;
+ }
+
+ dashdx = _dash[idx] * cx;
+ dashdy = _dash[idx] * cy;
+
+ if (phase == 0f) {
+ _curCurvepts[0] = x0 + dashdx;
+ _curCurvepts[1] = y0 + dashdy;
+ } else {
+ p = leftInThisDashSegment / _dash[idx];
+ _curCurvepts[0] = x0 + p * dashdx;
+ _curCurvepts[1] = y0 + p * dashdy;
+ }
+
+ goTo(_curCurvepts, 0, 4);
+
+ len -= leftInThisDashSegment;
+ // Advance to next dash segment
+ idx = (idx + 1) % dashLen;
+ dashOn = !dashOn;
+ phase = 0f;
+ }
+ }
+
+ // shared instance in Dasher
+ private final LengthIterator li = new LengthIterator();
+
+ // preconditions: curCurvepts must be an array of length at least 2 * type,
+ // that contains the curve we want to dash in the first type elements
+ private void somethingTo(int type) {
+ if (pointCurve(curCurvepts, type)) {
+ return;
+ }
+ li.initializeIterationOnCurve(curCurvepts, type);
+
+ // initially the current curve is at curCurvepts[0...type]
+ int curCurveoff = 0;
+ float lastSplitT = 0f;
+ float t;
+ float leftInThisDashSegment = dash[idx] - phase;
+
+ while ((t = li.next(leftInThisDashSegment)) < 1f) {
+ if (t != 0f) {
+ Helpers.subdivideAt((t - lastSplitT) / (1f - lastSplitT),
+ curCurvepts, curCurveoff,
+ curCurvepts, 0,
+ curCurvepts, type, type);
+ lastSplitT = t;
+ goTo(curCurvepts, 2, type);
+ curCurveoff = type;
+ }
+ // Advance to next dash segment
+ idx = (idx + 1) % dashLen;
+ dashOn = !dashOn;
+ phase = 0f;
+ leftInThisDashSegment = dash[idx];
+ }
+ goTo(curCurvepts, curCurveoff+2, type);
+ phase += li.lastSegLen();
+ if (phase >= dash[idx]) {
+ phase = 0f;
+ idx = (idx + 1) % dashLen;
+ dashOn = !dashOn;
+ }
+ // reset LengthIterator:
+ li.reset();
+ }
+
+ private static boolean pointCurve(float[] curve, int type) {
+ for (int i = 2; i < type; i++) {
+ if (curve[i] != curve[i-2]) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ // Objects of this class are used to iterate through curves. They return
+ // t values where the left side of the curve has a specified length.
+ // It does this by subdividing the input curve until a certain error
+ // condition has been met. A recursive subdivision procedure would
+ // return as many as 1<= 0; i--) {
+ Arrays.fill(recCurveStack[i], 0f);
+ }
+ Arrays.fill(sides, Side.LEFT);
+ Arrays.fill(curLeafCtrlPolyLengths, 0f);
+ Arrays.fill(nextRoots, 0f);
+ Arrays.fill(flatLeafCoefCache, 0f);
+ flatLeafCoefCache[2] = -1f;
+ }
+ }
+
+ void initializeIterationOnCurve(float[] pts, int type) {
+ // optimize arraycopy (8 values faster than 6 = type):
+ System.arraycopy(pts, 0, recCurveStack[0], 0, 8);
+ this.curveType = type;
+ this.recLevel = 0;
+ this.lastT = 0f;
+ this.lenAtLastT = 0f;
+ this.nextT = 0f;
+ this.lenAtNextT = 0f;
+ goLeft(); // initializes nextT and lenAtNextT properly
+ this.lenAtLastSplit = 0f;
+ if (recLevel > 0) {
+ this.sides[0] = Side.LEFT;
+ this.done = false;
+ } else {
+ // the root of the tree is a leaf so we're done.
+ this.sides[0] = Side.RIGHT;
+ this.done = true;
+ }
+ this.lastSegLen = 0f;
+ }
+
+ // 0 == false, 1 == true, -1 == invalid cached value.
+ private int cachedHaveLowAcceleration = -1;
+
+ private boolean haveLowAcceleration(float err) {
+ if (cachedHaveLowAcceleration == -1) {
+ final float len1 = curLeafCtrlPolyLengths[0];
+ final float len2 = curLeafCtrlPolyLengths[1];
+ // the test below is equivalent to !within(len1/len2, 1, err).
+ // It is using a multiplication instead of a division, so it
+ // should be a bit faster.
+ if (!Helpers.within(len1, len2, err*len2)) {
+ cachedHaveLowAcceleration = 0;
+ return false;
+ }
+ if (curveType == 8) {
+ final float len3 = curLeafCtrlPolyLengths[2];
+ // if len1 is close to 2 and 2 is close to 3, that probably
+ // means 1 is close to 3 so the second part of this test might
+ // not be needed, but it doesn't hurt to include it.
+ final float errLen3 = err * len3;
+ if (!(Helpers.within(len2, len3, errLen3) &&
+ Helpers.within(len1, len3, errLen3))) {
+ cachedHaveLowAcceleration = 0;
+ return false;
+ }
+ }
+ cachedHaveLowAcceleration = 1;
+ return true;
+ }
+
+ return (cachedHaveLowAcceleration == 1);
+ }
+
+ // we want to avoid allocations/gc so we keep this array so we
+ // can put roots in it,
+ private final float[] nextRoots = new float[4];
+
+ // caches the coefficients of the current leaf in its flattened
+ // form (see inside next() for what that means). The cache is
+ // invalid when it's third element is negative, since in any
+ // valid flattened curve, this would be >= 0.
+ private final float[] flatLeafCoefCache = new float[]{0f, 0f, -1f, 0f};
+
+ // returns the t value where the remaining curve should be split in
+ // order for the left subdivided curve to have length len. If len
+ // is >= than the length of the uniterated curve, it returns 1.
+ float next(final float len) {
+ final float targetLength = lenAtLastSplit + len;
+ while (lenAtNextT < targetLength) {
+ if (done) {
+ lastSegLen = lenAtNextT - lenAtLastSplit;
+ return 1f;
+ }
+ goToNextLeaf();
+ }
+ lenAtLastSplit = targetLength;
+ final float leaflen = lenAtNextT - lenAtLastT;
+ float t = (targetLength - lenAtLastT) / leaflen;
+
+ // cubicRootsInAB is a fairly expensive call, so we just don't do it
+ // if the acceleration in this section of the curve is small enough.
+ if (!haveLowAcceleration(0.05f)) {
+ // We flatten the current leaf along the x axis, so that we're
+ // left with a, b, c which define a 1D Bezier curve. We then
+ // solve this to get the parameter of the original leaf that
+ // gives us the desired length.
+ final float[] _flatLeafCoefCache = flatLeafCoefCache;
+
+ if (_flatLeafCoefCache[2] < 0) {
+ float x = 0f + curLeafCtrlPolyLengths[0],
+ y = x + curLeafCtrlPolyLengths[1];
+ if (curveType == 8) {
+ float z = y + curLeafCtrlPolyLengths[2];
+ _flatLeafCoefCache[0] = 3f * (x - y) + z;
+ _flatLeafCoefCache[1] = 3f * (y - 2f * x);
+ _flatLeafCoefCache[2] = 3f * x;
+ _flatLeafCoefCache[3] = -z;
+ } else if (curveType == 6) {
+ _flatLeafCoefCache[0] = 0f;
+ _flatLeafCoefCache[1] = y - 2f * x;
+ _flatLeafCoefCache[2] = 2f * x;
+ _flatLeafCoefCache[3] = -y;
+ }
+ }
+ float a = _flatLeafCoefCache[0];
+ float b = _flatLeafCoefCache[1];
+ float c = _flatLeafCoefCache[2];
+ float d = t * _flatLeafCoefCache[3];
+
+ // we use cubicRootsInAB here, because we want only roots in 0, 1,
+ // and our quadratic root finder doesn't filter, so it's just a
+ // matter of convenience.
+ int n = Helpers.cubicRootsInAB(a, b, c, d, nextRoots, 0, 0, 1);
+ if (n == 1 && !Float.isNaN(nextRoots[0])) {
+ t = nextRoots[0];
+ }
+ }
+ // t is relative to the current leaf, so we must make it a valid parameter
+ // of the original curve.
+ t = t * (nextT - lastT) + lastT;
+ if (t >= 1f) {
+ t = 1f;
+ done = true;
+ }
+ // even if done = true, if we're here, that means targetLength
+ // is equal to, or very, very close to the total length of the
+ // curve, so lastSegLen won't be too high. In cases where len
+ // overshoots the curve, this method will exit in the while
+ // loop, and lastSegLen will still be set to the right value.
+ lastSegLen = len;
+ return t;
+ }
+
+ float lastSegLen() {
+ return lastSegLen;
+ }
+
+ // go to the next leaf (in an inorder traversal) in the recursion tree
+ // preconditions: must be on a leaf, and that leaf must not be the root.
+ private void goToNextLeaf() {
+ // We must go to the first ancestor node that has an unvisited
+ // right child.
+ int _recLevel = recLevel;
+ final Side[] _sides = sides;
+
+ _recLevel--;
+ while(_sides[_recLevel] == Side.RIGHT) {
+ if (_recLevel == 0) {
+ recLevel = 0;
+ done = true;
+ return;
+ }
+ _recLevel--;
+ }
+
+ _sides[_recLevel] = Side.RIGHT;
+ // optimize arraycopy (8 values faster than 6 = type):
+ System.arraycopy(recCurveStack[_recLevel], 0,
+ recCurveStack[_recLevel+1], 0, 8);
+ _recLevel++;
+
+ recLevel = _recLevel;
+ goLeft();
+ }
+
+ // go to the leftmost node from the current node. Return its length.
+ private void goLeft() {
+ float len = onLeaf();
+ if (len >= 0f) {
+ lastT = nextT;
+ lenAtLastT = lenAtNextT;
+ nextT += (1 << (recLimit - recLevel)) * minTincrement;
+ lenAtNextT += len;
+ // invalidate caches
+ flatLeafCoefCache[2] = -1f;
+ cachedHaveLowAcceleration = -1;
+ } else {
+ Helpers.subdivide(recCurveStack[recLevel], 0,
+ recCurveStack[recLevel+1], 0,
+ recCurveStack[recLevel], 0, curveType);
+ sides[recLevel] = Side.LEFT;
+ recLevel++;
+ goLeft();
+ }
+ }
+
+ // this is a bit of a hack. It returns -1 if we're not on a leaf, and
+ // the length of the leaf if we are on a leaf.
+ private float onLeaf() {
+ float[] curve = recCurveStack[recLevel];
+ float polyLen = 0f;
+
+ float x0 = curve[0], y0 = curve[1];
+ for (int i = 2; i < curveType; i += 2) {
+ final float x1 = curve[i], y1 = curve[i+1];
+ final float len = Helpers.linelen(x0, y0, x1, y1);
+ polyLen += len;
+ curLeafCtrlPolyLengths[i/2 - 1] = len;
+ x0 = x1;
+ y0 = y1;
+ }
+
+ final float lineLen = Helpers.linelen(curve[0], curve[1],
+ curve[curveType-2],
+ curve[curveType-1]);
+ if ((polyLen - lineLen) < ERR || recLevel == recLimit) {
+ return (polyLen + lineLen) / 2f;
+ }
+ return -1f;
+ }
+ }
+
+ @Override
+ public void curveTo(float x1, float y1,
+ float x2, float y2,
+ float x3, float y3)
+ {
+ final float[] _curCurvepts = curCurvepts;
+ _curCurvepts[0] = x0; _curCurvepts[1] = y0;
+ _curCurvepts[2] = x1; _curCurvepts[3] = y1;
+ _curCurvepts[4] = x2; _curCurvepts[5] = y2;
+ _curCurvepts[6] = x3; _curCurvepts[7] = y3;
+ somethingTo(8);
+ }
+
+ @Override
+ public void quadTo(float x1, float y1, float x2, float y2) {
+ final float[] _curCurvepts = curCurvepts;
+ _curCurvepts[0] = x0; _curCurvepts[1] = y0;
+ _curCurvepts[2] = x1; _curCurvepts[3] = y1;
+ _curCurvepts[4] = x2; _curCurvepts[5] = y2;
+ somethingTo(6);
+ }
+
+ @Override
+ public void closePath() {
+ lineTo(sx, sy);
+ if (firstSegidx > 0) {
+ if (!dashOn || needsMoveTo) {
+ out.moveTo(sx, sy);
+ }
+ emitFirstSegments();
+ }
+ moveTo(sx, sy);
+ }
+
+ @Override
+ public void pathDone() {
+ if (firstSegidx > 0) {
+ out.moveTo(sx, sy);
+ emitFirstSegments();
+ }
+ out.pathDone();
+
+ // Dispose this instance:
+ dispose();
+ }
+
+ @Override
+ public long getNativeConsumer() {
+ throw new InternalError("Dasher does not use a native consumer");
+ }
+}
+
--- /dev/null 2015-11-23 13:25:11.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/marlin/FloatArrayCache.java 2015-11-23 13:25:11.000000000 -0800
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2015, 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.
+ */
+
+package sun.java2d.marlin;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import static sun.java2d.marlin.MarlinUtils.logException;
+import static sun.java2d.marlin.MarlinUtils.logInfo;
+
+final class FloatArrayCache implements MarlinConst {
+
+ private final int arraySize;
+ private final ArrayDeque floatArrays;
+ // stats
+ private int getOp = 0;
+ private int createOp = 0;
+ private int returnOp = 0;
+
+ void dumpStats() {
+ if (getOp > 0) {
+ logInfo("FloatArrayCache[" + arraySize + "]: get: " + getOp
+ + " created: " + createOp + " - returned: " + returnOp
+ + " :: cache size: " + floatArrays.size());
+ }
+ }
+
+ FloatArrayCache(final int arraySize) {
+ this.arraySize = arraySize;
+ // small but enough: almost 1 cache line
+ this.floatArrays = new ArrayDeque(6);
+ }
+
+ float[] getArray() {
+ if (doStats) {
+ getOp++;
+ }
+
+ // use cache
+ final float[] array = floatArrays.pollLast();
+
+ if (array != null) {
+ return array;
+ }
+
+ if (doStats) {
+ createOp++;
+ }
+
+ return new float[arraySize];
+ }
+
+ void putDirtyArray(final float[] array, final int length) {
+ if (length != arraySize) {
+ if (doChecks) {
+ System.out.println("ArrayCache: bad length = " + length);
+ }
+ return;
+ }
+ if (doStats) {
+ returnOp++;
+ }
+
+ // NO clean-up of array data = DIRTY ARRAY
+
+ if (doCleanDirty) {
+ // Force zero-fill dirty arrays:
+ Arrays.fill(array, 0, array.length, 0f);
+ }
+
+ // fill cache:
+ floatArrays.addLast(array);
+ }
+
+ void putArray(final float[] array, final int length,
+ final int fromIndex, final int toIndex)
+ {
+ if (length != arraySize) {
+ if (doChecks) {
+ System.out.println("ArrayCache: bad length = " + length);
+ }
+ return;
+ }
+ if (doStats) {
+ returnOp++;
+ }
+
+ // clean-up array of dirty part[fromIndex; toIndex[
+ fill(array, fromIndex, toIndex, 0f);
+
+ // fill cache:
+ floatArrays.addLast(array);
+ }
+
+ static void fill(final float[] array, final int fromIndex,
+ final int toIndex, final float value)
+ {
+ // clear array data:
+ /*
+ * Arrays.fill is faster than System.arraycopy(empty array)
+ * or Unsafe.setMemory(byte 0)
+ */
+ if (toIndex != 0) {
+ Arrays.fill(array, fromIndex, toIndex, value);
+ }
+
+ if (doChecks) {
+ check(array, 0, array.length, value);
+ }
+ }
+
+ static void check(final float[] array, final int fromIndex,
+ final int toIndex, final float value)
+ {
+ if (doChecks) {
+ // check zero on full array:
+ for (int i = fromIndex; i < toIndex; i++) {
+ if (array[i] != value) {
+ logException("Invalid array value at " + i + "\n"
+ + Arrays.toString(array), new Throwable());
+
+ // ensure array is correctly filled:
+ Arrays.fill(array, value);
+
+ return;
+ }
+ }
+ }
+ }
+}
--- /dev/null 2015-11-23 13:25:12.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/marlin/FloatMath.java 2015-11-23 13:25:12.000000000 -0800
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2015, 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.
+ */
+package sun.java2d.marlin;
+
+import sun.misc.DoubleConsts;
+import sun.misc.FloatConsts;
+
+/**
+ * Faster Math ceil / floor routines derived from StrictMath
+ */
+public final class FloatMath implements MarlinConst {
+
+ // overflow / NaN handling enabled:
+ static final boolean CHECK_OVERFLOW = true;
+ static final boolean CHECK_NAN = true;
+
+ private FloatMath() {
+ // utility class
+ }
+
+ // faster inlined min/max functions in the branch prediction is high
+ static float max(final float a, final float b) {
+ // no NaN handling
+ return (a >= b) ? a : b;
+ }
+
+ static int max(final int a, final int b) {
+ return (a >= b) ? a : b;
+ }
+
+ static int min(final int a, final int b) {
+ return (a <= b) ? a : b;
+ }
+
+ /**
+ * Returns the smallest (closest to negative infinity) {@code float} value
+ * that is greater than or equal to the argument and is equal to a
+ * mathematical integer. Special cases:
+ *
If the argument value is already equal to a mathematical integer,
+ * then the result is the same as the argument.
If the argument is NaN
+ * or an infinity or positive zero or negative zero, then the result is the
+ * same as the argument.
If the argument value is less than zero but
+ * greater than -1.0, then the result is negative zero.
Note that the
+ * value of {@code StrictMath.ceil(x)} is exactly the value of
+ * {@code -StrictMath.floor(-x)}.
+ *
+ * @param a a value.
+ * @return the smallest (closest to negative infinity) floating-point value
+ * that is greater than or equal to the argument and is equal to a
+ * mathematical integer.
+ */
+ public static float ceil_f(final float a) {
+ // Derived from StrictMath.ceil(double):
+
+ // Inline call to Math.getExponent(a) to
+ // compute only once Float.floatToRawIntBits(a)
+ final int doppel = Float.floatToRawIntBits(a);
+
+ final int exponent = ((doppel & FloatConsts.EXP_BIT_MASK)
+ >> (FloatConsts.SIGNIFICAND_WIDTH - 1))
+ - FloatConsts.EXP_BIAS;
+
+ if (exponent < 0) {
+ /*
+ * Absolute value of argument is less than 1.
+ * floorOrceil(-0.0) => -0.0
+ * floorOrceil(+0.0) => +0.0
+ */
+ return ((a == 0) ? a :
+ ( (a < 0f) ? -0f : 1f) );
+ }
+ if (CHECK_OVERFLOW && (exponent >= 23)) { // 52 for double
+ /*
+ * Infinity, NaN, or a value so large it must be integral.
+ */
+ return a;
+ }
+ // Else the argument is either an integral value already XOR it
+ // has to be rounded to one.
+ assert exponent >= 0 && exponent <= 22; // 51 for double
+
+ final int intpart = doppel
+ & (~(FloatConsts.SIGNIF_BIT_MASK >> exponent));
+
+ if (intpart == doppel) {
+ return a; // integral value (including 0)
+ }
+
+ // 0 handled above as an integer
+ // sign: 1 for negative, 0 for positive numbers
+ // add : 0 for negative and 1 for positive numbers
+ return Float.intBitsToFloat(intpart) + ((~intpart) >>> 31);
+ }
+
+ /**
+ * Returns the largest (closest to positive infinity) {@code float} value
+ * that is less than or equal to the argument and is equal to a mathematical
+ * integer. Special cases:
+ *
If the argument value is already equal to a mathematical integer,
+ * then the result is the same as the argument.
If the argument is NaN
+ * or an infinity or positive zero or negative zero, then the result is the
+ * same as the argument.
+ *
+ * @param a a value.
+ * @return the largest (closest to positive infinity) floating-point value
+ * that less than or equal to the argument and is equal to a mathematical
+ * integer.
+ */
+ public static float floor_f(final float a) {
+ // Derived from StrictMath.floor(double):
+
+ // Inline call to Math.getExponent(a) to
+ // compute only once Float.floatToRawIntBits(a)
+ final int doppel = Float.floatToRawIntBits(a);
+
+ final int exponent = ((doppel & FloatConsts.EXP_BIT_MASK)
+ >> (FloatConsts.SIGNIFICAND_WIDTH - 1))
+ - FloatConsts.EXP_BIAS;
+
+ if (exponent < 0) {
+ /*
+ * Absolute value of argument is less than 1.
+ * floorOrceil(-0.0) => -0.0
+ * floorOrceil(+0.0) => +0.0
+ */
+ return ((a == 0) ? a :
+ ( (a < 0f) ? -1f : 0f) );
+ }
+ if (CHECK_OVERFLOW && (exponent >= 23)) { // 52 for double
+ /*
+ * Infinity, NaN, or a value so large it must be integral.
+ */
+ return a;
+ }
+ // Else the argument is either an integral value already XOR it
+ // has to be rounded to one.
+ assert exponent >= 0 && exponent <= 22; // 51 for double
+
+ final int intpart = doppel
+ & (~(FloatConsts.SIGNIF_BIT_MASK >> exponent));
+
+ if (intpart == doppel) {
+ return a; // integral value (including 0)
+ }
+
+ // 0 handled above as an integer
+ // sign: 1 for negative, 0 for positive numbers
+ // add : -1 for negative and 0 for positive numbers
+ return Float.intBitsToFloat(intpart) + (intpart >> 31);
+ }
+
+ /**
+ * Faster alternative to ceil(float) optimized for the integer domain
+ * and supporting NaN and +/-Infinity.
+ *
+ * @param a a value.
+ * @return the largest (closest to positive infinity) integer value
+ * that less than or equal to the argument and is equal to a mathematical
+ * integer.
+ */
+ public static int ceil_int(final float a) {
+ final int intpart = (int) a;
+
+ if (a <= intpart
+ || (CHECK_OVERFLOW && intpart == Integer.MAX_VALUE)
+ || CHECK_NAN && Float.isNaN(a)) {
+ return intpart;
+ }
+ return intpart + 1;
+ }
+
+ /**
+ * Faster alternative to floor(float) optimized for the integer domain
+ * and supporting NaN and +/-Infinity.
+ *
+ * @param a a value.
+ * @return the largest (closest to positive infinity) floating-point value
+ * that less than or equal to the argument and is equal to a mathematical
+ * integer.
+ */
+ public static int floor_int(final float a) {
+ final int intpart = (int) a;
+
+ if (a >= intpart
+ || (CHECK_OVERFLOW && intpart == Integer.MIN_VALUE)
+ || CHECK_NAN && Float.isNaN(a)) {
+ return intpart;
+ }
+ return intpart - 1;
+ }
+
+ /**
+ * Returns a floating-point power of two in the normal range.
+ */
+ static double powerOfTwoD(int n) {
+ assert (n >= DoubleConsts.MIN_EXPONENT && n <= DoubleConsts.MAX_EXPONENT);
+ return Double.longBitsToDouble((((long) n + (long) DoubleConsts.EXP_BIAS)
+ << (DoubleConsts.SIGNIFICAND_WIDTH - 1))
+ & DoubleConsts.EXP_BIT_MASK);
+ }
+}
--- /dev/null 2015-11-23 13:25:13.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/marlin/Helpers.java 2015-11-23 13:25:13.000000000 -0800
@@ -0,0 +1,441 @@
+/*
+ * Copyright (c) 2007, 2015, 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.
+ */
+
+package sun.java2d.marlin;
+
+import static java.lang.Math.PI;
+import static java.lang.Math.cos;
+import static java.lang.Math.sqrt;
+import static java.lang.Math.cbrt;
+import static java.lang.Math.acos;
+
+final class Helpers implements MarlinConst {
+
+ private Helpers() {
+ throw new Error("This is a non instantiable class");
+ }
+
+ static boolean within(final float x, final float y, final float err) {
+ final float d = y - x;
+ return (d <= err && d >= -err);
+ }
+
+ static boolean within(final double x, final double y, final double err) {
+ final double d = y - x;
+ return (d <= err && d >= -err);
+ }
+
+ static int quadraticRoots(final float a, final float b,
+ final float c, float[] zeroes, final int off)
+ {
+ int ret = off;
+ float t;
+ if (a != 0f) {
+ final float dis = b*b - 4*a*c;
+ if (dis > 0f) {
+ final float sqrtDis = (float)Math.sqrt(dis);
+ // depending on the sign of b we use a slightly different
+ // algorithm than the traditional one to find one of the roots
+ // so we can avoid adding numbers of different signs (which
+ // might result in loss of precision).
+ if (b >= 0f) {
+ zeroes[ret++] = (2f * c) / (-b - sqrtDis);
+ zeroes[ret++] = (-b - sqrtDis) / (2f * a);
+ } else {
+ zeroes[ret++] = (-b + sqrtDis) / (2f * a);
+ zeroes[ret++] = (2f * c) / (-b + sqrtDis);
+ }
+ } else if (dis == 0f) {
+ t = (-b) / (2f * a);
+ zeroes[ret++] = t;
+ }
+ } else {
+ if (b != 0f) {
+ t = (-c) / b;
+ zeroes[ret++] = t;
+ }
+ }
+ return ret - off;
+ }
+
+ // find the roots of g(t) = d*t^3 + a*t^2 + b*t + c in [A,B)
+ static int cubicRootsInAB(float d, float a, float b, float c,
+ float[] pts, final int off,
+ final float A, final float B)
+ {
+ if (d == 0f) {
+ int num = quadraticRoots(a, b, c, pts, off);
+ return filterOutNotInAB(pts, off, num, A, B) - off;
+ }
+ // From Graphics Gems:
+ // http://tog.acm.org/resources/GraphicsGems/gems/Roots3And4.c
+ // (also from awt.geom.CubicCurve2D. But here we don't need as
+ // much accuracy and we don't want to create arrays so we use
+ // our own customized version).
+
+ // normal form: x^3 + ax^2 + bx + c = 0
+ a /= d;
+ b /= d;
+ c /= d;
+
+ // substitute x = y - A/3 to eliminate quadratic term:
+ // x^3 +Px + Q = 0
+ //
+ // Since we actually need P/3 and Q/2 for all of the
+ // calculations that follow, we will calculate
+ // p = P/3
+ // q = Q/2
+ // instead and use those values for simplicity of the code.
+ double sq_A = a * a;
+ double p = (1.0/3.0) * ((-1.0/3.0) * sq_A + b);
+ double q = (1.0/2.0) * ((2.0/27.0) * a * sq_A - (1.0/3.0) * a * b + c);
+
+ // use Cardano's formula
+
+ double cb_p = p * p * p;
+ double D = q * q + cb_p;
+
+ int num;
+ if (D < 0.0) {
+ // see: http://en.wikipedia.org/wiki/Cubic_function#Trigonometric_.28and_hyperbolic.29_method
+ final double phi = (1.0/3.0) * acos(-q / sqrt(-cb_p));
+ final double t = 2.0 * sqrt(-p);
+
+ pts[ off+0 ] = (float)( t * cos(phi));
+ pts[ off+1 ] = (float)(-t * cos(phi + (PI / 3.0)));
+ pts[ off+2 ] = (float)(-t * cos(phi - (PI / 3.0)));
+ num = 3;
+ } else {
+ final double sqrt_D = sqrt(D);
+ final double u = cbrt(sqrt_D - q);
+ final double v = - cbrt(sqrt_D + q);
+
+ pts[ off ] = (float)(u + v);
+ num = 1;
+
+ if (within(D, 0.0, 1e-8)) {
+ pts[off+1] = -(pts[off] / 2f);
+ num = 2;
+ }
+ }
+
+ final float sub = (1f/3f) * a;
+
+ for (int i = 0; i < num; ++i) {
+ pts[ off+i ] -= sub;
+ }
+
+ return filterOutNotInAB(pts, off, num, A, B) - off;
+ }
+
+ static float evalCubic(final float a, final float b,
+ final float c, final float d,
+ final float t)
+ {
+ return t * (t * (t * a + b) + c) + d;
+ }
+
+ static float evalQuad(final float a, final float b,
+ final float c, final float t)
+ {
+ return t * (t * a + b) + c;
+ }
+
+ // returns the index 1 past the last valid element remaining after filtering
+ static int filterOutNotInAB(float[] nums, final int off, final int len,
+ final float a, final float b)
+ {
+ int ret = off;
+ for (int i = off, end = off + len; i < end; i++) {
+ if (nums[i] >= a && nums[i] < b) {
+ nums[ret++] = nums[i];
+ }
+ }
+ return ret;
+ }
+
+ static float polyLineLength(float[] poly, final int off, final int nCoords) {
+ assert nCoords % 2 == 0 && poly.length >= off + nCoords : "";
+ float acc = 0;
+ for (int i = off + 2; i < off + nCoords; i += 2) {
+ acc += linelen(poly[i], poly[i+1], poly[i-2], poly[i-1]);
+ }
+ return acc;
+ }
+
+ static float linelen(float x1, float y1, float x2, float y2) {
+ final float dx = x2 - x1;
+ final float dy = y2 - y1;
+ return (float)Math.sqrt(dx*dx + dy*dy);
+ }
+
+ static void subdivide(float[] src, int srcoff, float[] left, int leftoff,
+ float[] right, int rightoff, int type)
+ {
+ switch(type) {
+ case 6:
+ Helpers.subdivideQuad(src, srcoff, left, leftoff, right, rightoff);
+ return;
+ case 8:
+ Helpers.subdivideCubic(src, srcoff, left, leftoff, right, rightoff);
+ return;
+ default:
+ throw new InternalError("Unsupported curve type");
+ }
+ }
+
+ static void isort(float[] a, int off, int len) {
+ for (int i = off + 1, end = off + len; i < end; i++) {
+ float ai = a[i];
+ int j = i - 1;
+ for (; j >= off && a[j] > ai; j--) {
+ a[j+1] = a[j];
+ }
+ a[j+1] = ai;
+ }
+ }
+
+ // Most of these are copied from classes in java.awt.geom because we need
+ // float versions of these functions, and Line2D, CubicCurve2D,
+ // QuadCurve2D don't provide them.
+ /**
+ * Subdivides the cubic curve specified by the coordinates
+ * stored in the src array at indices srcoff
+ * through (srcoff + 7) and stores the
+ * resulting two subdivided curves into the two result arrays at the
+ * corresponding indices.
+ * Either or both of the left and right
+ * arrays may be null or a reference to the same array
+ * as the src array.
+ * Note that the last point in the first subdivided curve is the
+ * same as the first point in the second subdivided curve. Thus,
+ * it is possible to pass the same array for left
+ * and right and to use offsets, such as rightoff
+ * equals (leftoff + 6), in order
+ * to avoid allocating extra storage for this common point.
+ * @param src the array holding the coordinates for the source curve
+ * @param srcoff the offset into the array of the beginning of the
+ * the 6 source coordinates
+ * @param left the array for storing the coordinates for the first
+ * half of the subdivided curve
+ * @param leftoff the offset into the array of the beginning of the
+ * the 6 left coordinates
+ * @param right the array for storing the coordinates for the second
+ * half of the subdivided curve
+ * @param rightoff the offset into the array of the beginning of the
+ * the 6 right coordinates
+ * @since 1.7
+ */
+ static void subdivideCubic(float src[], int srcoff,
+ float left[], int leftoff,
+ float right[], int rightoff)
+ {
+ float x1 = src[srcoff + 0];
+ float y1 = src[srcoff + 1];
+ float ctrlx1 = src[srcoff + 2];
+ float ctrly1 = src[srcoff + 3];
+ float ctrlx2 = src[srcoff + 4];
+ float ctrly2 = src[srcoff + 5];
+ float x2 = src[srcoff + 6];
+ float y2 = src[srcoff + 7];
+ if (left != null) {
+ left[leftoff + 0] = x1;
+ left[leftoff + 1] = y1;
+ }
+ if (right != null) {
+ right[rightoff + 6] = x2;
+ right[rightoff + 7] = y2;
+ }
+ x1 = (x1 + ctrlx1) / 2f;
+ y1 = (y1 + ctrly1) / 2f;
+ x2 = (x2 + ctrlx2) / 2f;
+ y2 = (y2 + ctrly2) / 2f;
+ float centerx = (ctrlx1 + ctrlx2) / 2f;
+ float centery = (ctrly1 + ctrly2) / 2f;
+ ctrlx1 = (x1 + centerx) / 2f;
+ ctrly1 = (y1 + centery) / 2f;
+ ctrlx2 = (x2 + centerx) / 2f;
+ ctrly2 = (y2 + centery) / 2f;
+ centerx = (ctrlx1 + ctrlx2) / 2f;
+ centery = (ctrly1 + ctrly2) / 2f;
+ if (left != null) {
+ left[leftoff + 2] = x1;
+ left[leftoff + 3] = y1;
+ left[leftoff + 4] = ctrlx1;
+ left[leftoff + 5] = ctrly1;
+ left[leftoff + 6] = centerx;
+ left[leftoff + 7] = centery;
+ }
+ if (right != null) {
+ right[rightoff + 0] = centerx;
+ right[rightoff + 1] = centery;
+ right[rightoff + 2] = ctrlx2;
+ right[rightoff + 3] = ctrly2;
+ right[rightoff + 4] = x2;
+ right[rightoff + 5] = y2;
+ }
+ }
+
+
+ static void subdivideCubicAt(float t, float src[], int srcoff,
+ float left[], int leftoff,
+ float right[], int rightoff)
+ {
+ float x1 = src[srcoff + 0];
+ float y1 = src[srcoff + 1];
+ float ctrlx1 = src[srcoff + 2];
+ float ctrly1 = src[srcoff + 3];
+ float ctrlx2 = src[srcoff + 4];
+ float ctrly2 = src[srcoff + 5];
+ float x2 = src[srcoff + 6];
+ float y2 = src[srcoff + 7];
+ if (left != null) {
+ left[leftoff + 0] = x1;
+ left[leftoff + 1] = y1;
+ }
+ if (right != null) {
+ right[rightoff + 6] = x2;
+ right[rightoff + 7] = y2;
+ }
+ x1 = x1 + t * (ctrlx1 - x1);
+ y1 = y1 + t * (ctrly1 - y1);
+ x2 = ctrlx2 + t * (x2 - ctrlx2);
+ y2 = ctrly2 + t * (y2 - ctrly2);
+ float centerx = ctrlx1 + t * (ctrlx2 - ctrlx1);
+ float centery = ctrly1 + t * (ctrly2 - ctrly1);
+ ctrlx1 = x1 + t * (centerx - x1);
+ ctrly1 = y1 + t * (centery - y1);
+ ctrlx2 = centerx + t * (x2 - centerx);
+ ctrly2 = centery + t * (y2 - centery);
+ centerx = ctrlx1 + t * (ctrlx2 - ctrlx1);
+ centery = ctrly1 + t * (ctrly2 - ctrly1);
+ if (left != null) {
+ left[leftoff + 2] = x1;
+ left[leftoff + 3] = y1;
+ left[leftoff + 4] = ctrlx1;
+ left[leftoff + 5] = ctrly1;
+ left[leftoff + 6] = centerx;
+ left[leftoff + 7] = centery;
+ }
+ if (right != null) {
+ right[rightoff + 0] = centerx;
+ right[rightoff + 1] = centery;
+ right[rightoff + 2] = ctrlx2;
+ right[rightoff + 3] = ctrly2;
+ right[rightoff + 4] = x2;
+ right[rightoff + 5] = y2;
+ }
+ }
+
+ static void subdivideQuad(float src[], int srcoff,
+ float left[], int leftoff,
+ float right[], int rightoff)
+ {
+ float x1 = src[srcoff + 0];
+ float y1 = src[srcoff + 1];
+ float ctrlx = src[srcoff + 2];
+ float ctrly = src[srcoff + 3];
+ float x2 = src[srcoff + 4];
+ float y2 = src[srcoff + 5];
+ if (left != null) {
+ left[leftoff + 0] = x1;
+ left[leftoff + 1] = y1;
+ }
+ if (right != null) {
+ right[rightoff + 4] = x2;
+ right[rightoff + 5] = y2;
+ }
+ x1 = (x1 + ctrlx) / 2f;
+ y1 = (y1 + ctrly) / 2f;
+ x2 = (x2 + ctrlx) / 2f;
+ y2 = (y2 + ctrly) / 2f;
+ ctrlx = (x1 + x2) / 2f;
+ ctrly = (y1 + y2) / 2f;
+ if (left != null) {
+ left[leftoff + 2] = x1;
+ left[leftoff + 3] = y1;
+ left[leftoff + 4] = ctrlx;
+ left[leftoff + 5] = ctrly;
+ }
+ if (right != null) {
+ right[rightoff + 0] = ctrlx;
+ right[rightoff + 1] = ctrly;
+ right[rightoff + 2] = x2;
+ right[rightoff + 3] = y2;
+ }
+ }
+
+ static void subdivideQuadAt(float t, float src[], int srcoff,
+ float left[], int leftoff,
+ float right[], int rightoff)
+ {
+ float x1 = src[srcoff + 0];
+ float y1 = src[srcoff + 1];
+ float ctrlx = src[srcoff + 2];
+ float ctrly = src[srcoff + 3];
+ float x2 = src[srcoff + 4];
+ float y2 = src[srcoff + 5];
+ if (left != null) {
+ left[leftoff + 0] = x1;
+ left[leftoff + 1] = y1;
+ }
+ if (right != null) {
+ right[rightoff + 4] = x2;
+ right[rightoff + 5] = y2;
+ }
+ x1 = x1 + t * (ctrlx - x1);
+ y1 = y1 + t * (ctrly - y1);
+ x2 = ctrlx + t * (x2 - ctrlx);
+ y2 = ctrly + t * (y2 - ctrly);
+ ctrlx = x1 + t * (x2 - x1);
+ ctrly = y1 + t * (y2 - y1);
+ if (left != null) {
+ left[leftoff + 2] = x1;
+ left[leftoff + 3] = y1;
+ left[leftoff + 4] = ctrlx;
+ left[leftoff + 5] = ctrly;
+ }
+ if (right != null) {
+ right[rightoff + 0] = ctrlx;
+ right[rightoff + 1] = ctrly;
+ right[rightoff + 2] = x2;
+ right[rightoff + 3] = y2;
+ }
+ }
+
+ static void subdivideAt(float t, float src[], int srcoff,
+ float left[], int leftoff,
+ float right[], int rightoff, int size)
+ {
+ switch(size) {
+ case 8:
+ subdivideCubicAt(t, src, srcoff, left, leftoff, right, rightoff);
+ return;
+ case 6:
+ subdivideQuadAt(t, src, srcoff, left, leftoff, right, rightoff);
+ return;
+ }
+ }
+}
--- /dev/null 2015-11-23 13:25:14.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/marlin/IntArrayCache.java 2015-11-23 13:25:14.000000000 -0800
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2015, 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.
+ */
+
+package sun.java2d.marlin;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import static sun.java2d.marlin.MarlinUtils.logException;
+import static sun.java2d.marlin.MarlinUtils.logInfo;
+
+final class IntArrayCache implements MarlinConst {
+
+ private final int arraySize;
+ private final ArrayDeque intArrays;
+ // stats
+ private int getOp = 0;
+ private int createOp = 0;
+ private int returnOp = 0;
+
+ void dumpStats() {
+ if (getOp > 0) {
+ logInfo("IntArrayCache[" + arraySize + "]: get: " + getOp
+ + " created: " + createOp + " - returned: " + returnOp
+ + " :: cache size: " + intArrays.size());
+ }
+ }
+
+ IntArrayCache(final int arraySize) {
+ this.arraySize = arraySize;
+ // small but enough: almost 1 cache line
+ this.intArrays = new ArrayDeque(6);
+ }
+
+ int[] getArray() {
+ if (doStats) {
+ getOp++;
+ }
+
+ // use cache:
+ final int[] array = intArrays.pollLast();
+ if (array != null) {
+ return array;
+ }
+
+ if (doStats) {
+ createOp++;
+ }
+
+ return new int[arraySize];
+ }
+
+ void putDirtyArray(final int[] array, final int length) {
+ if (length != arraySize) {
+ if (doChecks) {
+ System.out.println("ArrayCache: bad length = " + length);
+ }
+ return;
+ }
+ if (doStats) {
+ returnOp++;
+ }
+
+ // NO clean-up of array data = DIRTY ARRAY
+
+ if (doCleanDirty) {
+ // Force zero-fill dirty arrays:
+ Arrays.fill(array, 0, array.length, 0);
+ }
+
+ // fill cache:
+ intArrays.addLast(array);
+ }
+
+ void putArray(final int[] array, final int length,
+ final int fromIndex, final int toIndex)
+ {
+ if (length != arraySize) {
+ if (doChecks) {
+ System.out.println("ArrayCache: bad length = " + length);
+ }
+ return;
+ }
+ if (doStats) {
+ returnOp++;
+ }
+
+ // clean-up array of dirty part[fromIndex; toIndex[
+ fill(array, fromIndex, toIndex, 0);
+
+ // fill cache:
+ intArrays.addLast(array);
+ }
+
+ static void fill(final int[] array, final int fromIndex,
+ final int toIndex, final int value)
+ {
+ // clear array data:
+ /*
+ * Arrays.fill is faster than System.arraycopy(empty array)
+ * or Unsafe.setMemory(byte 0)
+ */
+ if (toIndex != 0) {
+ Arrays.fill(array, fromIndex, toIndex, value);
+ }
+
+ if (doChecks) {
+ check(array, 0, array.length, value);
+ }
+ }
+
+ static void check(final int[] array, final int fromIndex,
+ final int toIndex, final int value)
+ {
+ if (doChecks) {
+ // check zero on full array:
+ for (int i = fromIndex; i < toIndex; i++) {
+ if (array[i] != value) {
+ logException("Invalid array value at " + i + "\n"
+ + Arrays.toString(array), new Throwable());
+
+ // ensure array is correctly filled:
+ Arrays.fill(array, value);
+
+ return;
+ }
+ }
+ }
+ }
+}
--- /dev/null 2015-11-23 13:25:15.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/marlin/MarlinCache.java 2015-11-23 13:25:15.000000000 -0800
@@ -0,0 +1,676 @@
+/*
+ * Copyright (c) 2007, 2015, 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.
+ */
+
+package sun.java2d.marlin;
+
+import jdk.internal.misc.Unsafe;
+
+/**
+ * An object used to cache pre-rendered complex paths.
+ *
+ * @see Renderer
+ */
+public final class MarlinCache implements MarlinConst {
+
+ static final boolean FORCE_RLE = MarlinProperties.isForceRLE();
+ static final boolean FORCE_NO_RLE = MarlinProperties.isForceNoRLE();
+ // minimum width to try using RLE encoding:
+ static final int RLE_MIN_WIDTH
+ = Math.max(BLOCK_SIZE, MarlinProperties.getRLEMinWidth());
+ // maximum width for RLE encoding:
+ // values are stored as int [x|alpha] where alpha is 8 bits
+ static final int RLE_MAX_WIDTH = 1 << (24 - 1);
+
+ // 2048 (pixelSize) alpha values (width) x 32 rows (tile) = 64K bytes
+ // x1 instead of 4 bytes (RLE) ie 1/4 capacity or average good RLE compression
+ static final long INITIAL_CHUNK_ARRAY = TILE_SIZE * INITIAL_PIXEL_DIM; // 64K
+
+ // The alpha map used by this object (taken out of our map cache) to convert
+ // pixel coverage counts gotten from MarlinCache (which are in the range
+ // [0, maxalpha]) into alpha values, which are in [0,256).
+ static final byte[] ALPHA_MAP;
+
+ static final OffHeapArray ALPHA_MAP_UNSAFE;
+
+ static {
+ final byte[] _ALPHA_MAP = buildAlphaMap(MAX_AA_ALPHA);
+
+ ALPHA_MAP_UNSAFE = new OffHeapArray(_ALPHA_MAP, _ALPHA_MAP.length); // 1K
+ ALPHA_MAP =_ALPHA_MAP;
+
+ final Unsafe _unsafe = OffHeapArray.unsafe;
+ final long addr = ALPHA_MAP_UNSAFE.address;
+
+ for (int i = 0; i < _ALPHA_MAP.length; i++) {
+ _unsafe.putByte(addr + i, _ALPHA_MAP[i]);
+ }
+ }
+
+ int bboxX0, bboxY0, bboxX1, bboxY1;
+
+ // 1D dirty arrays
+ // row index in rowAAChunk[]
+ final long[] rowAAChunkIndex = new long[TILE_SIZE];
+ // first pixel (inclusive) for each row
+ final int[] rowAAx0 = new int[TILE_SIZE];
+ // last pixel (exclusive) for each row
+ final int[] rowAAx1 = new int[TILE_SIZE];
+ // encoding mode (0=raw, 1=RLE encoding) for each row
+ final int[] rowAAEnc = new int[TILE_SIZE];
+ // coded length (RLE encoding) for each row
+ final long[] rowAALen = new long[TILE_SIZE];
+ // last position in RLE decoding for each row (getAlpha):
+ final long[] rowAAPos = new long[TILE_SIZE];
+
+ // dirty off-heap array containing pixel coverages for (32) rows (packed)
+ // if encoding=raw, it contains alpha coverage values (val) as integer
+ // if encoding=RLE, it contains tuples (val, last x-coordinate exclusive)
+ // use rowAAx0/rowAAx1 to get row indices within this chunk
+ final OffHeapArray rowAAChunk;
+
+ // current position in rowAAChunk array
+ long rowAAChunkPos;
+
+ // touchedTile[i] is the sum of all the alphas in the tile with
+ // x=j*TILE_SIZE+bboxX0.
+ int[] touchedTile;
+
+ // per-thread renderer context
+ final RendererContext rdrCtx;
+
+ // large cached touchedTile (dirty)
+ final int[] touchedTile_initial = new int[INITIAL_ARRAY]; // 1 tile line
+
+ int tileMin, tileMax;
+
+ boolean useRLE = false;
+
+ MarlinCache(final RendererContext rdrCtx) {
+ this.rdrCtx = rdrCtx;
+
+ rowAAChunk = new OffHeapArray(rdrCtx, INITIAL_CHUNK_ARRAY);
+
+ touchedTile = touchedTile_initial;
+
+ // tile used marks:
+ tileMin = Integer.MAX_VALUE;
+ tileMax = Integer.MIN_VALUE;
+ }
+
+ void init(int minx, int miny, int maxx, int maxy, int edgeSumDeltaY)
+ {
+ // assert maxy >= miny && maxx >= minx;
+ bboxX0 = minx;
+ bboxY0 = miny;
+ bboxX1 = maxx;
+ bboxY1 = maxy;
+
+ final int width = (maxx - minx);
+
+ if (FORCE_NO_RLE) {
+ useRLE = false;
+ } else if (FORCE_RLE) {
+ useRLE = true;
+ } else {
+ // heuristics: use both bbox area and complexity
+ // ie number of primitives:
+
+ // fast check min and max width (maxx < 23bits):
+ if (width <= RLE_MIN_WIDTH || width >= RLE_MAX_WIDTH) {
+ useRLE = false;
+ } else {
+ // perimeter approach: how fit the total length into given height:
+
+ // if stroking: meanCrossings /= 2 => divide edgeSumDeltaY by 2
+ final int heightSubPixel
+ = (((maxy - miny) << SUBPIXEL_LG_POSITIONS_Y) << rdrCtx.stroking);
+
+ // check meanDist > block size:
+ // check width / (meanCrossings - 1) >= RLE_THRESHOLD
+
+ // fast case: (meanCrossingPerPixel <= 2) means 1 span only
+ useRLE = (edgeSumDeltaY <= (heightSubPixel << 1))
+ // note: already checked (meanCrossingPerPixel <= 2)
+ // rewritten to avoid division:
+ || (width * heightSubPixel) >
+ ((edgeSumDeltaY - heightSubPixel) << BLOCK_SIZE_LG);
+// ((edgeSumDeltaY - heightSubPixel) * RLE_THRESHOLD);
+// ((edgeSumDeltaY - heightSubPixel) << BLOCK_TH_LG);
+
+ if (doTrace && !useRLE) {
+ final float meanCrossings
+ = ((float) edgeSumDeltaY) / heightSubPixel;
+ final float meanDist = width / (meanCrossings - 1);
+
+ System.out.println("High complexity: "
+ + " for bbox[width = " + width
+ + " height = " + (maxy - miny)
+ + "] edgeSumDeltaY = " + edgeSumDeltaY
+ + " heightSubPixel = " + heightSubPixel
+ + " meanCrossings = "+ meanCrossings
+ + " meanDist = " + meanDist
+ + " width = " + (width * heightSubPixel)
+ + " <= criteria: " + ((edgeSumDeltaY - heightSubPixel) << BLOCK_SIZE_LG)
+ );
+ }
+ }
+ }
+
+ // the ceiling of (maxy - miny + 1) / TILE_SIZE;
+ final int nxTiles = (width + TILE_SIZE) >> TILE_SIZE_LG;
+
+ if (nxTiles > INITIAL_ARRAY) {
+ if (doStats) {
+ RendererContext.stats.stat_array_marlincache_touchedTile
+ .add(nxTiles);
+ }
+ touchedTile = rdrCtx.getIntArray(nxTiles);
+ }
+ }
+
+ /**
+ * Disposes this cache:
+ * clean up before reusing this instance
+ */
+ void dispose() {
+ // Reset touchedTile if needed:
+ resetTileLine(0);
+
+ // Return arrays:
+ if (touchedTile != touchedTile_initial) {
+ rdrCtx.putIntArray(touchedTile, 0, 0); // already zero filled
+ touchedTile = touchedTile_initial;
+ }
+ // At last: resize back off-heap rowAA to initial size
+ if (rowAAChunk.length != INITIAL_CHUNK_ARRAY) {
+ // note: may throw OOME:
+ rowAAChunk.resize(INITIAL_CHUNK_ARRAY);
+ }
+ if (doCleanDirty) {
+ // Force zero-fill dirty arrays:
+ rowAAChunk.fill(BYTE_0);
+ }
+ }
+
+ void resetTileLine(final int pminY) {
+ // update bboxY0 to process a complete tile line [0 - 32]
+ bboxY0 = pminY;
+
+ // reset current pos
+ if (doStats) {
+ RendererContext.stats.stat_cache_rowAAChunk.add(rowAAChunkPos);
+ }
+ rowAAChunkPos = 0L;
+
+ // Reset touchedTile:
+ if (tileMin != Integer.MAX_VALUE) {
+ if (doStats) {
+ RendererContext.stats.stat_cache_tiles.add(tileMax - tileMin);
+ }
+ // clean only dirty touchedTile:
+ if (tileMax == 1) {
+ touchedTile[0] = 0;
+ } else {
+ IntArrayCache.fill(touchedTile, tileMin, tileMax, 0);
+ }
+ // reset tile used marks:
+ tileMin = Integer.MAX_VALUE;
+ tileMax = Integer.MIN_VALUE;
+ }
+
+ if (doCleanDirty) {
+ // Force zero-fill dirty arrays:
+ rowAAChunk.fill(BYTE_0);
+ }
+ }
+
+ void clearAARow(final int y) {
+ // process tile line [0 - 32]
+ final int row = y - bboxY0;
+
+ // update pixel range:
+ rowAAx0[row] = 0; // first pixel inclusive
+ rowAAx1[row] = 0; // last pixel exclusive
+ rowAAEnc[row] = 0; // raw encoding
+
+ // note: leave rowAAChunkIndex[row] undefined
+ // and rowAALen[row] & rowAAPos[row] (RLE)
+ }
+
+ /**
+ * Copy the given alpha data into the rowAA cache
+ * @param alphaRow alpha data to copy from
+ * @param y y pixel coordinate
+ * @param px0 first pixel inclusive x0
+ * @param px1 last pixel exclusive x1
+ */
+ void copyAARowNoRLE(final int[] alphaRow, final int y,
+ final int px0, final int px1)
+ {
+ if (doMonitors) {
+ RendererContext.stats.mon_rdr_copyAARow.start();
+ }
+
+ // skip useless pixels above boundary
+ final int px_bbox1 = FloatMath.min(px1, bboxX1);
+
+ if (doLogBounds) {
+ MarlinUtils.logInfo("row = [" + px0 + " ... " + px_bbox1
+ + " (" + px1 + ") [ for y=" + y);
+ }
+
+ final int row = y - bboxY0;
+
+ // update pixel range:
+ rowAAx0[row] = px0; // first pixel inclusive
+ rowAAx1[row] = px_bbox1; // last pixel exclusive
+ rowAAEnc[row] = 0; // raw encoding
+
+ // get current position (bytes):
+ final long pos = rowAAChunkPos;
+ // update row index to current position:
+ rowAAChunkIndex[row] = pos;
+
+ // determine need array size (may overflow):
+ final long needSize = pos + (px_bbox1 - px0);
+
+ // update next position (bytes):
+ rowAAChunkPos = needSize;
+
+ // update row data:
+ final OffHeapArray _rowAAChunk = rowAAChunk;
+ // ensure rowAAChunk capacity:
+ if (_rowAAChunk.length < needSize) {
+ expandRowAAChunk(needSize);
+ }
+ if (doStats) {
+ RendererContext.stats.stat_cache_rowAA.add(px_bbox1 - px0);
+ }
+
+ // rowAA contains only alpha values for range[x0; x1[
+ final int[] _touchedTile = touchedTile;
+ final int _TILE_SIZE_LG = TILE_SIZE_LG;
+
+ final int from = px0 - bboxX0; // first pixel inclusive
+ final int to = px_bbox1 - bboxX0; // last pixel exclusive
+
+ final Unsafe _unsafe = OffHeapArray.unsafe;
+ final long SIZE_BYTE = 1L;
+ final long addr_alpha = ALPHA_MAP_UNSAFE.address;
+ long addr_off = _rowAAChunk.address + pos;
+
+ // compute alpha sum into rowAA:
+ for (int x = from, val = 0; x < to; x++) {
+ // alphaRow is in [0; MAX_COVERAGE]
+ val += alphaRow[x]; // [from; to[
+
+ // ensure values are in [0; MAX_AA_ALPHA] range
+ if (DO_AA_RANGE_CHECK) {
+ if (val < 0) {
+ System.out.println("Invalid coverage = " + val);
+ val = 0;
+ }
+ if (val > MAX_AA_ALPHA) {
+ System.out.println("Invalid coverage = " + val);
+ val = MAX_AA_ALPHA;
+ }
+ }
+
+ // store alpha sum (as byte):
+ if (val == 0) {
+ _unsafe.putByte(addr_off, (byte)0); // [0..255]
+ } else {
+ _unsafe.putByte(addr_off, _unsafe.getByte(addr_alpha + val)); // [0..255]
+
+ // update touchedTile
+ _touchedTile[x >> _TILE_SIZE_LG] += val;
+ }
+ addr_off += SIZE_BYTE;
+ }
+
+ // update tile used marks:
+ int tx = from >> _TILE_SIZE_LG; // inclusive
+ if (tx < tileMin) {
+ tileMin = tx;
+ }
+
+ tx = ((to - 1) >> _TILE_SIZE_LG) + 1; // exclusive (+1 to be sure)
+ if (tx > tileMax) {
+ tileMax = tx;
+ }
+
+ if (doLogBounds) {
+ MarlinUtils.logInfo("clear = [" + from + " ... " + to + "[");
+ }
+
+ // Clear alpha row for reuse:
+ IntArrayCache.fill(alphaRow, from, px1 - bboxX0, 0);
+
+ if (doMonitors) {
+ RendererContext.stats.mon_rdr_copyAARow.stop();
+ }
+ }
+
+ void copyAARowRLE_WithBlockFlags(final int[] blkFlags, final int[] alphaRow,
+ final int y, final int px0, final int px1)
+ {
+ if (doMonitors) {
+ RendererContext.stats.mon_rdr_copyAARow.start();
+ }
+
+ // Copy rowAA data into the piscesCache if one is present
+ final int _bboxX0 = bboxX0;
+
+ // process tile line [0 - 32]
+ final int row = y - bboxY0;
+ final int from = px0 - _bboxX0; // first pixel inclusive
+
+ // skip useless pixels above boundary
+ final int px_bbox1 = FloatMath.min(px1, bboxX1);
+ final int to = px_bbox1 - _bboxX0; // last pixel exclusive
+
+ if (doLogBounds) {
+ MarlinUtils.logInfo("row = [" + px0 + " ... " + px_bbox1
+ + " (" + px1 + ") [ for y=" + y);
+ }
+
+ // get current position:
+ final long initialPos = startRLERow(row, px0, px_bbox1);
+
+ // determine need array size:
+ // pessimistic: max needed size = deltaX x 4 (1 int)
+ final int maxLen = (to - from);
+ final long needSize = initialPos + (maxLen << 2);
+
+ // update row data:
+ OffHeapArray _rowAAChunk = rowAAChunk;
+ // ensure rowAAChunk capacity:
+ if (_rowAAChunk.length < needSize) {
+ expandRowAAChunk(needSize);
+ }
+
+ final Unsafe _unsafe = OffHeapArray.unsafe;
+ final long SIZE_INT = 4L;
+ final long addr_alpha = ALPHA_MAP_UNSAFE.address;
+ long addr_off = _rowAAChunk.address + initialPos;
+
+ final int[] _touchedTile = touchedTile;
+ final int _TILE_SIZE_LG = TILE_SIZE_LG;
+ final int _BLK_SIZE_LG = BLOCK_SIZE_LG;
+
+ // traverse flagged blocks:
+ final int blkW = (from >> _BLK_SIZE_LG);
+ final int blkE = (to >> _BLK_SIZE_LG) + 1;
+
+ // Perform run-length encoding and store results in the piscesCache
+ int val = 0;
+ int cx0 = from;
+ int runLen;
+
+ final int _MAX_VALUE = Integer.MAX_VALUE;
+ int last_t0 = _MAX_VALUE;
+
+ int skip = 0;
+
+ for (int t = blkW, blk_x0, blk_x1, cx, delta; t <= blkE; t++) {
+ if (blkFlags[t] != 0) {
+ blkFlags[t] = 0;
+
+ if (last_t0 == _MAX_VALUE) {
+ last_t0 = t;
+ }
+ continue;
+ }
+ if (last_t0 != _MAX_VALUE) {
+ // emit blocks:
+ blk_x0 = FloatMath.max(last_t0 << _BLK_SIZE_LG, from);
+ last_t0 = _MAX_VALUE;
+
+ // (last block pixel+1) inclusive => +1
+ blk_x1 = FloatMath.min((t << _BLK_SIZE_LG) + 1, to);
+
+ for (cx = blk_x0; cx < blk_x1; cx++) {
+ if ((delta = alphaRow[cx]) != 0) {
+ alphaRow[cx] = 0;
+
+ // not first rle entry:
+ if (cx != cx0) {
+ runLen = cx - cx0;
+
+ // store alpha coverage (ensure within bounds):
+ // as [absX|val] where:
+ // absX is the absolute x-coordinate:
+ // note: last pixel exclusive (>= 0)
+ // note: it should check X is smaller than 23bits (overflow)!
+
+ // special case to encode entries into a single int:
+ if (val == 0) {
+ _unsafe.putInt(addr_off,
+ ((_bboxX0 + cx) << 8)
+ );
+ } else {
+ _unsafe.putInt(addr_off,
+ ((_bboxX0 + cx) << 8)
+ | (((int) _unsafe.getByte(addr_alpha + val)) & 0xFF) // [0..255]
+ );
+
+ if (runLen == 1) {
+ _touchedTile[cx0 >> _TILE_SIZE_LG] += val;
+ } else {
+ touchTile(cx0, val, cx, runLen, _touchedTile);
+ }
+ }
+ addr_off += SIZE_INT;
+
+ if (doStats) {
+ RendererContext.stats.hist_tile_generator_encoding_runLen
+ .add(runLen);
+ }
+ cx0 = cx;
+ }
+
+ // alpha value = running sum of coverage delta:
+ val += delta;
+
+ // ensure values are in [0; MAX_AA_ALPHA] range
+ if (DO_AA_RANGE_CHECK) {
+ if (val < 0) {
+ System.out.println("Invalid coverage = " + val);
+ val = 0;
+ }
+ if (val > MAX_AA_ALPHA) {
+ System.out.println("Invalid coverage = " + val);
+ val = MAX_AA_ALPHA;
+ }
+ }
+ }
+ }
+ } else if (doStats) {
+ skip++;
+ }
+ }
+
+ // Process remaining RLE run:
+ runLen = to - cx0;
+
+ // store alpha coverage (ensure within bounds):
+ // as (int)[absX|val] where:
+ // absX is the absolute x-coordinate in bits 31 to 8 and val in bits 0..7
+ // note: last pixel exclusive (>= 0)
+ // note: it should check X is smaller than 23bits (overflow)!
+
+ // special case to encode entries into a single int:
+ if (val == 0) {
+ _unsafe.putInt(addr_off,
+ ((_bboxX0 + to) << 8)
+ );
+ } else {
+ _unsafe.putInt(addr_off,
+ ((_bboxX0 + to) << 8)
+ | (((int) _unsafe.getByte(addr_alpha + val)) & 0xFF) // [0..255]
+ );
+
+ if (runLen == 1) {
+ _touchedTile[cx0 >> _TILE_SIZE_LG] += val;
+ } else {
+ touchTile(cx0, val, to, runLen, _touchedTile);
+ }
+ }
+ addr_off += SIZE_INT;
+
+ if (doStats) {
+ RendererContext.stats.hist_tile_generator_encoding_runLen
+ .add(runLen);
+ }
+
+ long len = (addr_off - _rowAAChunk.address);
+
+ // update coded length as bytes:
+ rowAALen[row] = (len - initialPos);
+
+ // update current position:
+ rowAAChunkPos = len;
+
+ if (doStats) {
+ RendererContext.stats.stat_cache_rowAA.add(rowAALen[row]);
+ RendererContext.stats.hist_tile_generator_encoding_ratio.add(
+ (100 * skip) / (blkE - blkW)
+ );
+ }
+
+ // update tile used marks:
+ int tx = from >> _TILE_SIZE_LG; // inclusive
+ if (tx < tileMin) {
+ tileMin = tx;
+ }
+
+ tx = ((to - 1) >> _TILE_SIZE_LG) + 1; // exclusive (+1 to be sure)
+ if (tx > tileMax) {
+ tileMax = tx;
+ }
+
+ // Clear alpha row for reuse:
+ if (px1 > bboxX1) {
+ alphaRow[to ] = 0;
+ alphaRow[to + 1] = 0;
+ }
+ if (doChecks) {
+ IntArrayCache.check(blkFlags, 0, blkFlags.length, 0);
+ IntArrayCache.check(alphaRow, 0, alphaRow.length, 0);
+ }
+
+ if (doMonitors) {
+ RendererContext.stats.mon_rdr_copyAARow.stop();
+ }
+ }
+
+ long startRLERow(final int row, final int x0, final int x1) {
+ // rows are supposed to be added by increasing y.
+ rowAAx0[row] = x0; // first pixel inclusive
+ rowAAx1[row] = x1; // last pixel exclusive
+ rowAAEnc[row] = 1; // RLE encoding
+ rowAAPos[row] = 0L; // position = 0
+
+ // update row index to current position:
+ return (rowAAChunkIndex[row] = rowAAChunkPos);
+ }
+
+ private void expandRowAAChunk(final long needSize) {
+ if (doStats) {
+ RendererContext.stats.stat_array_marlincache_rowAAChunk
+ .add(needSize);
+ }
+
+ // note: throw IOOB if neededSize > 2Gb:
+ final long newSize = ArrayCache.getNewLargeSize(rowAAChunk.length, needSize);
+
+ rowAAChunk.resize(newSize);
+ }
+
+ private void touchTile(final int x0, final int val, final int x1,
+ final int runLen,
+ final int[] _touchedTile)
+ {
+ // the x and y of the current row, minus bboxX0, bboxY0
+ // process tile line [0 - 32]
+ final int _TILE_SIZE_LG = TILE_SIZE_LG;
+
+ // update touchedTile
+ int tx = (x0 >> _TILE_SIZE_LG);
+
+ // handle trivial case: same tile (x0, x0+runLen)
+ if (tx == (x1 >> _TILE_SIZE_LG)) {
+ // same tile:
+ _touchedTile[tx] += val * runLen;
+ return;
+ }
+
+ final int tx1 = (x1 - 1) >> _TILE_SIZE_LG;
+
+ if (tx <= tx1) {
+ final int nextTileXCoord = (tx + 1) << _TILE_SIZE_LG;
+ _touchedTile[tx++] += val * (nextTileXCoord - x0);
+ }
+ if (tx < tx1) {
+ // don't go all the way to tx1 - we need to handle the last
+ // tile as a special case (just like we did with the first
+ final int tileVal = (val << _TILE_SIZE_LG);
+ for (; tx < tx1; tx++) {
+ _touchedTile[tx] += tileVal;
+ }
+ }
+ // they will be equal unless x0 >> TILE_SIZE_LG == tx1
+ if (tx == tx1) {
+ final int txXCoord = tx << _TILE_SIZE_LG;
+ final int nextTileXCoord = (tx + 1) << _TILE_SIZE_LG;
+
+ final int lastXCoord = (nextTileXCoord <= x1) ? nextTileXCoord : x1;
+ _touchedTile[tx] += val * (lastXCoord - txXCoord);
+ }
+ }
+
+ int alphaSumInTile(final int x) {
+ return touchedTile[(x - bboxX0) >> TILE_SIZE_LG];
+ }
+
+ @Override
+ public String toString() {
+ return "bbox = ["
+ + bboxX0 + ", " + bboxY0 + " => "
+ + bboxX1 + ", " + bboxY1 + "]\n";
+ }
+
+ private static byte[] buildAlphaMap(final int maxalpha) {
+ // double size !
+ final byte[] alMap = new byte[maxalpha << 1];
+ final int halfmaxalpha = maxalpha >> 2;
+ for (int i = 0; i <= maxalpha; i++) {
+ alMap[i] = (byte) ((i * 255 + halfmaxalpha) / maxalpha);
+// System.out.println("alphaMap[" + i + "] = "
+// + Byte.toUnsignedInt(alMap[i]));
+ }
+ return alMap;
+ }
+}
--- /dev/null 2015-11-23 13:25:16.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/marlin/MarlinConst.java 2015-11-23 13:25:15.000000000 -0800
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2015, 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.
+ */
+
+package sun.java2d.marlin;
+
+/**
+ * Marlin constant holder using System properties
+ */
+interface MarlinConst {
+ // enable Logs (logger or stdout)
+ static final boolean enableLogs = false;
+ // enable Logger
+ static final boolean useLogger = enableLogs && MarlinProperties.isUseLogger();
+
+ // log new RendererContext
+ static final boolean logCreateContext = enableLogs
+ && MarlinProperties.isLogCreateContext();
+ // log misc.Unsafe alloc/realloc/free
+ static final boolean logUnsafeMalloc = enableLogs
+ && MarlinProperties.isLogUnsafeMalloc();
+
+ // do statistics
+ static final boolean doStats = enableLogs && MarlinProperties.isDoStats();
+ // do monitors
+ // disabled to reduce byte-code size a bit...
+ static final boolean doMonitors = enableLogs && false; // MarlinProperties.isDoMonitors();
+ // do checks
+ static final boolean doChecks = false; // MarlinProperties.isDoChecks();
+
+ // do AA range checks: disable when algorithm / code is stable
+ static final boolean DO_AA_RANGE_CHECK = false;
+
+ // enable logs
+ static final boolean doLogWidenArray = enableLogs && false;
+ // enable oversize logs
+ static final boolean doLogOverSize = enableLogs && false;
+ // enable traces
+ static final boolean doTrace = enableLogs && false;
+ // do flush monitors
+ static final boolean doFlushMonitors = true;
+ // use one polling thread to dump statistics/monitors
+ static final boolean useDumpThread = false;
+ // thread dump interval (ms)
+ static final long statDump = 5000L;
+
+ // do clean dirty array
+ static final boolean doCleanDirty = false;
+
+ // flag to use line simplifier
+ static final boolean useSimplifier = MarlinProperties.isUseSimplifier();
+
+ // flag to enable logs related bounds checks
+ static final boolean doLogBounds = enableLogs && false;
+
+ // Initial Array sizing (initial context capacity) ~ 512K
+
+ // 2048 pixel (width x height) for initial capacity
+ static final int INITIAL_PIXEL_DIM
+ = MarlinProperties.getInitialImageSize();
+
+ // typical array sizes: only odd numbers allowed below
+ static final int INITIAL_ARRAY = 256;
+ static final int INITIAL_SMALL_ARRAY = 1024;
+ static final int INITIAL_MEDIUM_ARRAY = 4096;
+ static final int INITIAL_LARGE_ARRAY = 8192;
+ static final int INITIAL_ARRAY_16K = 16384;
+ static final int INITIAL_ARRAY_32K = 32768;
+ // alpha row dimension
+ static final int INITIAL_AA_ARRAY = INITIAL_PIXEL_DIM;
+
+ // initial edges (24 bytes) = 24K [ints] = 96K
+ static final int INITIAL_EDGES_CAPACITY = 4096 * 24; // 6 ints per edges
+
+ // zero value as byte
+ static final byte BYTE_0 = (byte) 0;
+
+ // subpixels expressed as log2
+ public static final int SUBPIXEL_LG_POSITIONS_X
+ = MarlinProperties.getSubPixel_Log2_X();
+ public static final int SUBPIXEL_LG_POSITIONS_Y
+ = MarlinProperties.getSubPixel_Log2_Y();
+
+ // number of subpixels
+ public static final int SUBPIXEL_POSITIONS_X = 1 << (SUBPIXEL_LG_POSITIONS_X);
+ public static final int SUBPIXEL_POSITIONS_Y = 1 << (SUBPIXEL_LG_POSITIONS_Y);
+
+ public static final float NORM_SUBPIXELS
+ = (float)Math.sqrt(( SUBPIXEL_POSITIONS_X * SUBPIXEL_POSITIONS_X
+ + SUBPIXEL_POSITIONS_Y * SUBPIXEL_POSITIONS_Y)/2.0);
+
+ public static final int MAX_AA_ALPHA
+ = SUBPIXEL_POSITIONS_X * SUBPIXEL_POSITIONS_Y;
+
+ public static final int TILE_SIZE_LG = MarlinProperties.getTileSize_Log2();
+ public static final int TILE_SIZE = 1 << TILE_SIZE_LG; // 32 by default
+
+ public static final int BLOCK_SIZE_LG = MarlinProperties.getBlockSize_Log2();
+ public static final int BLOCK_SIZE = 1 << BLOCK_SIZE_LG;
+}
--- /dev/null 2015-11-23 13:25:17.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/marlin/MarlinProperties.java 2015-11-23 13:25:16.000000000 -0800
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2007, 2015, 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.
+ */
+
+package sun.java2d.marlin;
+
+import java.security.AccessController;
+import static sun.java2d.marlin.MarlinUtils.logInfo;
+import sun.security.action.GetPropertyAction;
+
+public final class MarlinProperties {
+
+ private MarlinProperties() {
+ // no-op
+ }
+
+ // marlin system properties
+
+ public static boolean isUseThreadLocal() {
+ return getBoolean("sun.java2d.renderer.useThreadLocal", "true");
+ }
+
+ /**
+ * Return the initial pixel size used to define initial arrays
+ * (tile AA chunk, alpha line, buckets)
+ *
+ * @return 64 < initial pixel size < 32768 (2048 by default)
+ */
+ public static int getInitialImageSize() {
+ return getInteger("sun.java2d.renderer.pixelsize", 2048, 64, 32 * 1024);
+ }
+
+ /**
+ * Return the log(2) corresponding to subpixel on x-axis (
+ *
+ * @return 1 (2 subpixels) < initial pixel size < 4 (256 subpixels)
+ * (3 by default ie 8 subpixels)
+ */
+ public static int getSubPixel_Log2_X() {
+ return getInteger("sun.java2d.renderer.subPixel_log2_X", 3, 1, 8);
+ }
+
+ /**
+ * Return the log(2) corresponding to subpixel on y-axis (
+ *
+ * @return 1 (2 subpixels) < initial pixel size < 8 (256 subpixels)
+ * (3 by default ie 8 subpixels)
+ */
+ public static int getSubPixel_Log2_Y() {
+ return getInteger("sun.java2d.renderer.subPixel_log2_Y", 3, 1, 8);
+ }
+
+ /**
+ * Return the log(2) corresponding to the square tile size in pixels
+ *
+ * @return 3 (8x8 pixels) < tile size < 8 (256x256 pixels)
+ * (5 by default ie 32x32 pixels)
+ */
+ public static int getTileSize_Log2() {
+ return getInteger("sun.java2d.renderer.tileSize_log2", 5, 3, 8);
+ }
+
+ /**
+ * Return the log(2) corresponding to the block size in pixels
+ *
+ * @return 3 (8 pixels) < block size < 8 (256 pixels)
+ * (5 by default ie 32 pixels)
+ */
+ public static int getBlockSize_Log2() {
+ return getInteger("sun.java2d.renderer.blockSize_log2", 5, 3, 8);
+ }
+
+ // RLE / blockFlags settings
+
+ public static boolean isForceRLE() {
+ return getBoolean("sun.java2d.renderer.forceRLE", "false");
+ }
+
+ public static boolean isForceNoRLE() {
+ return getBoolean("sun.java2d.renderer.forceNoRLE", "false");
+ }
+
+ public static boolean isUseTileFlags() {
+ return getBoolean("sun.java2d.renderer.useTileFlags", "true");
+ }
+
+ public static boolean isUseTileFlagsWithHeuristics() {
+ return isUseTileFlags()
+ && getBoolean("sun.java2d.renderer.useTileFlags.useHeuristics", "true");
+ }
+
+ public static int getRLEMinWidth() {
+ return getInteger("sun.java2d.renderer.rleMinWidth", 64, 0, Integer.MAX_VALUE);
+ }
+
+ // optimisation parameters
+
+ public static boolean isUseSimplifier() {
+ return getBoolean("sun.java2d.renderer.useSimplifier", "false");
+ }
+
+ // debugging parameters
+
+ public static boolean isDoStats() {
+ return getBoolean("sun.java2d.renderer.doStats", "false");
+ }
+
+ public static boolean isDoMonitors() {
+ return getBoolean("sun.java2d.renderer.doMonitors", "false");
+ }
+
+ public static boolean isDoChecks() {
+ return getBoolean("sun.java2d.renderer.doChecks", "false");
+ }
+
+ // logging parameters
+
+ public static boolean isUseLogger() {
+ return getBoolean("sun.java2d.renderer.useLogger", "false");
+ }
+
+ public static boolean isLogCreateContext() {
+ return getBoolean("sun.java2d.renderer.logCreateContext", "false");
+ }
+
+ public static boolean isLogUnsafeMalloc() {
+ return getBoolean("sun.java2d.renderer.logUnsafeMalloc", "false");
+ }
+
+ // system property utilities
+ static boolean getBoolean(final String key, final String def) {
+ return Boolean.valueOf(AccessController.doPrivileged(
+ new GetPropertyAction(key, def)));
+ }
+
+ static int getInteger(final String key, final int def,
+ final int min, final int max)
+ {
+ final String property = AccessController.doPrivileged(
+ new GetPropertyAction(key));
+
+ int value = def;
+ if (property != null) {
+ try {
+ value = Integer.decode(property);
+ } catch (NumberFormatException e) {
+ logInfo("Invalid integer value for " + key + " = " + property);
+ }
+ }
+
+ // check for invalid values
+ if ((value < min) || (value > max)) {
+ logInfo("Invalid value for " + key + " = " + value
+ + "; expected value in range[" + min + ", " + max + "] !");
+ value = def;
+ }
+ return value;
+ }
+
+}
--- /dev/null 2015-11-23 13:25:17.000000000 -0800
+++ new/src/java.desktop/share/classes/sun/java2d/marlin/MarlinRenderingEngine.java 2015-11-23 13:25:17.000000000 -0800
@@ -0,0 +1,1064 @@
+/*
+ * Copyright (c) 2007, 2015, 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.
+ */
+
+package sun.java2d.marlin;
+
+import java.awt.BasicStroke;
+import java.awt.Shape;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Path2D;
+import java.awt.geom.PathIterator;
+import java.lang.ref.Reference;
+import java.security.AccessController;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import static sun.java2d.marlin.MarlinUtils.logInfo;
+import sun.awt.geom.PathConsumer2D;
+import sun.java2d.pipe.AATileGenerator;
+import sun.java2d.pipe.Region;
+import sun.java2d.pipe.RenderingEngine;
+import sun.security.action.GetPropertyAction;
+
+/**
+ * Marlin RendererEngine implementation (derived from Pisces)
+ */
+public class MarlinRenderingEngine extends RenderingEngine
+ implements MarlinConst
+{
+ private static enum NormMode {ON_WITH_AA, ON_NO_AA, OFF}
+
+ private static final float MIN_PEN_SIZE = 1f / NORM_SUBPIXELS;
+
+ /**
+ * Public constructor
+ */
+ public MarlinRenderingEngine() {
+ super();
+ logSettings(MarlinRenderingEngine.class.getName());
+ }
+
+ /**
+ * Create a widened path as specified by the parameters.
+ *
+ * The specified {@code src} {@link Shape} is widened according
+ * to the specified attribute parameters as per the
+ * {@link BasicStroke} specification.
+ *
+ * @param src the source path to be widened
+ * @param width the width of the widened path as per {@code BasicStroke}
+ * @param caps the end cap decorations as per {@code BasicStroke}
+ * @param join the segment join decorations as per {@code BasicStroke}
+ * @param miterlimit the miter limit as per {@code BasicStroke}
+ * @param dashes the dash length array as per {@code BasicStroke}
+ * @param dashphase the initial dash phase as per {@code BasicStroke}
+ * @return the widened path stored in a new {@code Shape} object
+ * @since 1.7
+ */
+ @Override
+ public Shape createStrokedShape(Shape src,
+ float width,
+ int caps,
+ int join,
+ float miterlimit,
+ float dashes[],
+ float dashphase)
+ {
+ final RendererContext rdrCtx = getRendererContext();
+ try {
+ // initialize a large copyable Path2D to avoid a lot of array growing:
+ final Path2D.Float p2d =
+ (rdrCtx.p2d == null) ?
+ (rdrCtx.p2d = new Path2D.Float(Path2D.WIND_NON_ZERO,
+ INITIAL_MEDIUM_ARRAY))
+ : rdrCtx.p2d;
+ // reset
+ p2d.reset();
+
+ strokeTo(rdrCtx,
+ src,
+ null,
+ width,
+ NormMode.OFF,
+ caps,
+ join,
+ miterlimit,
+ dashes,
+ dashphase,
+ rdrCtx.transformerPC2D.wrapPath2d(p2d)
+ );
+
+ // Use Path2D copy constructor (trim)
+ return new Path2D.Float(p2d);
+
+ } finally {
+ // recycle the RendererContext instance
+ returnRendererContext(rdrCtx);
+ }
+ }
+
+ /**
+ * Sends the geometry for a widened path as specified by the parameters
+ * to the specified consumer.
+ *
+ * The specified {@code src} {@link Shape} is widened according
+ * to the parameters specified by the {@link BasicStroke} object.
+ * Adjustments are made to the path as appropriate for the
+ * {@link VALUE_STROKE_NORMALIZE} hint if the {@code normalize}
+ * boolean parameter is true.
+ * Adjustments are made to the path as appropriate for the
+ * {@link VALUE_ANTIALIAS_ON} hint if the {@code antialias}
+ * boolean parameter is true.
+ *
+ * The geometry of the widened path is forwarded to the indicated
+ * {@link PathConsumer2D} object as it is calculated.
+ *
+ * @param src the source path to be widened
+ * @param bs the {@code BasicSroke} object specifying the
+ * decorations to be applied to the widened path
+ * @param normalize indicates whether stroke normalization should
+ * be applied
+ * @param antialias indicates whether or not adjustments appropriate
+ * to antialiased rendering should be applied
+ * @param consumer the {@code PathConsumer2D} instance to forward
+ * the widened geometry to
+ * @since 1.7
+ */
+ @Override
+ public void strokeTo(Shape src,
+ AffineTransform at,
+ BasicStroke bs,
+ boolean thin,
+ boolean normalize,
+ boolean antialias,
+ final PathConsumer2D consumer)
+ {
+ final NormMode norm = (normalize) ?
+ ((antialias) ? NormMode.ON_WITH_AA : NormMode.ON_NO_AA)
+ : NormMode.OFF;
+
+ final RendererContext rdrCtx = getRendererContext();
+ try {
+ strokeTo(rdrCtx, src, at, bs, thin, norm, antialias, consumer);
+ } finally {
+ // recycle the RendererContext instance
+ returnRendererContext(rdrCtx);
+ }
+ }
+
+ final void strokeTo(final RendererContext rdrCtx,
+ Shape src,
+ AffineTransform at,
+ BasicStroke bs,
+ boolean thin,
+ NormMode normalize,
+ boolean antialias,
+ PathConsumer2D pc2d)
+ {
+ float lw;
+ if (thin) {
+ if (antialias) {
+ lw = userSpaceLineWidth(at, MIN_PEN_SIZE);
+ } else {
+ lw = userSpaceLineWidth(at, 1.0f);
+ }
+ } else {
+ lw = bs.getLineWidth();
+ }
+ strokeTo(rdrCtx,
+ src,
+ at,
+ lw,
+ normalize,
+ bs.getEndCap(),
+ bs.getLineJoin(),
+ bs.getMiterLimit(),
+ bs.getDashArray(),
+ bs.getDashPhase(),
+ pc2d);
+ }
+
+ private final float userSpaceLineWidth(AffineTransform at, float lw) {
+
+ float widthScale;
+
+ if (at == null) {
+ widthScale = 1.0f;
+ } else if ((at.getType() & (AffineTransform.TYPE_GENERAL_TRANSFORM |
+ AffineTransform.TYPE_GENERAL_SCALE)) != 0) {
+ widthScale = (float)Math.sqrt(at.getDeterminant());
+ } else {
+ // First calculate the "maximum scale" of this transform.
+ double A = at.getScaleX(); // m00
+ double C = at.getShearX(); // m01
+ double B = at.getShearY(); // m10
+ double D = at.getScaleY(); // m11
+
+ /*
+ * Given a 2 x 2 affine matrix [ A B ] such that
+ * [ C D ]
+ * v' = [x' y'] = [Ax + Cy, Bx + Dy], we want to
+ * find the maximum magnitude (norm) of the vector v'
+ * with the constraint (x^2 + y^2 = 1).
+ * The equation to maximize is
+ * |v'| = sqrt((Ax+Cy)^2+(Bx+Dy)^2)
+ * or |v'| = sqrt((AA+BB)x^2 + 2(AC+BD)xy + (CC+DD)y^2).
+ * Since sqrt is monotonic we can maximize |v'|^2
+ * instead and plug in the substitution y = sqrt(1 - x^2).
+ * Trigonometric equalities can then be used to get
+ * rid of most of the sqrt terms.
+ */
+
+ double EA = A*A + B*B; // x^2 coefficient
+ double EB = 2.0*(A*C + B*D); // xy coefficient
+ double EC = C*C + D*D; // y^2 coefficient
+
+ /*
+ * There is a lot of calculus omitted here.
+ *
+ * Conceptually, in the interests of understanding the
+ * terms that the calculus produced we can consider
+ * that EA and EC end up providing the lengths along
+ * the major axes and the hypot term ends up being an
+ * adjustment for the additional length along the off-axis
+ * angle of rotated or sheared ellipses as well as an
+ * adjustment for the fact that the equation below
+ * averages the two major axis lengths. (Notice that
+ * the hypot term contains a part which resolves to the
+ * difference of these two axis lengths in the absence
+ * of rotation.)
+ *
+ * In the calculus, the ratio of the EB and (EA-EC) terms
+ * ends up being the tangent of 2*theta where theta is
+ * the angle that the long axis of the ellipse makes
+ * with the horizontal axis. Thus, this equation is
+ * calculating the length of the hypotenuse of a triangle
+ * along that axis.
+ */
+
+ double hypot = Math.sqrt(EB*EB + (EA-EC)*(EA-EC));
+ // sqrt omitted, compare to squared limits below.
+ double widthsquared = ((EA + EC + hypot)/2.0);
+
+ widthScale = (float)Math.sqrt(widthsquared);
+ }
+
+ return (lw / widthScale);
+ }
+
+ final void strokeTo(final RendererContext rdrCtx,
+ Shape src,
+ AffineTransform at,
+ float width,
+ NormMode normalize,
+ int caps,
+ int join,
+ float miterlimit,
+ float dashes[],
+ float dashphase,
+ PathConsumer2D pc2d)
+ {
+ // We use strokerat and outat so that in Stroker and Dasher we can work only
+ // with the pre-transformation coordinates. This will repeat a lot of
+ // computations done in the path iterator, but the alternative is to
+ // work with transformed paths and compute untransformed coordinates
+ // as needed. This would be faster but I do not think the complexity
+ // of working with both untransformed and transformed coordinates in
+ // the same code is worth it.
+ // However, if a path's width is constant after a transformation,
+ // we can skip all this untransforming.
+
+ // If normalization is off we save some transformations by not
+ // transforming the input to pisces. Instead, we apply the
+ // transformation after the path processing has been done.
+ // We can't do this if normalization is on, because it isn't a good
+ // idea to normalize before the transformation is applied.
+ AffineTransform strokerat = null;
+ AffineTransform outat = null;
+
+ PathIterator pi;
+ int dashLen = -1;
+ boolean recycleDashes = false;
+
+ if (at != null && !at.isIdentity()) {
+ final double a = at.getScaleX();
+ final double b = at.getShearX();
+ final double c = at.getShearY();
+ final double d = at.getScaleY();
+ final double det = a * d - c * b;
+
+ if (Math.abs(det) <= (2f * Float.MIN_VALUE)) {
+ // this rendering engine takes one dimensional curves and turns
+ // them into 2D shapes by giving them width.
+ // However, if everything is to be passed through a singular
+ // transformation, these 2D shapes will be squashed down to 1D
+ // again so, nothing can be drawn.
+
+ // Every path needs an initial moveTo and a pathDone. If these
+ // are not there this causes a SIGSEGV in libawt.so (at the time
+ // of writing of this comment (September 16, 2010)). Actually,
+ // I am not sure if the moveTo is necessary to avoid the SIGSEGV
+ // but the pathDone is definitely needed.
+ pc2d.moveTo(0f, 0f);
+ pc2d.pathDone();
+ return;
+ }
+
+ // If the transform is a constant multiple of an orthogonal transformation
+ // then every length is just multiplied by a constant, so we just
+ // need to transform input paths to stroker and tell stroker
+ // the scaled width. This condition is satisfied if
+ // a*b == -c*d && a*a+c*c == b*b+d*d. In the actual check below, we
+ // leave a bit of room for error.
+ if (nearZero(a*b + c*d) && nearZero(a*a + c*c - (b*b + d*d))) {
+ final float scale = (float) Math.sqrt(a*a + c*c);
+ if (dashes != null) {
+ recycleDashes = true;
+ dashLen = dashes.length;
+ final float[] newDashes;
+ if (dashLen <= INITIAL_ARRAY) {
+ newDashes = rdrCtx.dasher.dashes_initial;
+ } else {
+ if (doStats) {
+ RendererContext.stats.stat_array_dasher_dasher
+ .add(dashLen);
+ }
+ newDashes = rdrCtx.getDirtyFloatArray(dashLen);
+ }
+ System.arraycopy(dashes, 0, newDashes, 0, dashLen);
+ dashes = newDashes;
+ for (int i = 0; i < dashLen; i++) {
+ dashes[i] = scale * dashes[i];
+ }
+ dashphase = scale * dashphase;
+ }
+ width = scale * width;
+ pi = getNormalizingPathIterator(rdrCtx, normalize,
+ src.getPathIterator(at));
+
+ // by now strokerat == null && outat == null. Input paths to
+ // stroker (and maybe dasher) will have the full transform at
+ // applied to them and nothing will happen to the output paths.
+ } else {
+ if (normalize != NormMode.OFF) {
+ strokerat = at;
+ pi = getNormalizingPathIterator(rdrCtx, normalize,
+ src.getPathIterator(at));
+
+ // by now strokerat == at && outat == null. Input paths to
+ // stroker (and maybe dasher) will have the full transform at
+ // applied to them, then they will be normalized, and then
+ // the inverse of *only the non translation part of at* will
+ // be applied to the normalized paths. This won't cause problems
+ // in stroker, because, suppose at = T*A, where T is just the
+ // translation part of at, and A is the rest. T*A has already
+ // been applied to Stroker/Dasher's input. Then Ainv will be
+ // applied. Ainv*T*A is not equal to T, but it is a translation,
+ // which means that none of stroker's assumptions about its
+ // input will be violated. After all this, A will be applied
+ // to stroker's output.
+ } else {
+ outat = at;
+ pi = src.getPathIterator(null);
+ // outat == at && strokerat == null. This is because if no
+ // normalization is done, we can just apply all our
+ // transformations to stroker's output.
+ }
+ }
+ } else {
+ // either at is null or it's the identity. In either case
+ // we don't transform the path.
+ pi = getNormalizingPathIterator(rdrCtx, normalize,
+ src.getPathIterator(null));
+ }
+
+ if (useSimplifier) {
+ // Use simplifier after stroker before Renderer
+ // to remove collinear segments (notably due to cap square)
+ pc2d = rdrCtx.simplifier.init(pc2d);
+ }
+
+ // by now, at least one of outat and strokerat will be null. Unless at is not
+ // a constant multiple of an orthogonal transformation, they will both be
+ // null. In other cases, outat == at if normalization is off, and if
+ // normalization is on, strokerat == at.
+ final TransformingPathConsumer2D transformerPC2D = rdrCtx.transformerPC2D;
+ pc2d = transformerPC2D.transformConsumer(pc2d, outat);
+ pc2d = transformerPC2D.deltaTransformConsumer(pc2d, strokerat);
+
+ pc2d = rdrCtx.stroker.init(pc2d, width, caps, join, miterlimit);
+
+ if (dashes != null) {
+ if (!recycleDashes) {
+ dashLen = dashes.length;
+ }
+ pc2d = rdrCtx.dasher.init(pc2d, dashes, dashLen, dashphase,
+ recycleDashes);
+ }
+ pc2d = transformerPC2D.inverseDeltaTransformConsumer(pc2d, strokerat);
+ pathTo(rdrCtx, pi, pc2d);
+
+ /*
+ * Pipeline seems to be:
+ * shape.getPathIterator
+ * -> NormalizingPathIterator
+ * -> inverseDeltaTransformConsumer
+ * -> Dasher
+ * -> Stroker
+ * -> deltaTransformConsumer OR transformConsumer
+ *
+ * -> CollinearSimplifier to remove redundant segments
+ *
+ * -> pc2d = Renderer (bounding box)
+ */
+ }
+
+ private static boolean nearZero(final double num) {
+ return Math.abs(num) < 2.0 * Math.ulp(num);
+ }
+
+ PathIterator getNormalizingPathIterator(final RendererContext rdrCtx,
+ final NormMode mode,
+ final PathIterator src)
+ {
+ switch (mode) {
+ case ON_WITH_AA:
+ // NormalizingPathIterator NearestPixelCenter:
+ return rdrCtx.nPCPathIterator.init(src);
+ case ON_NO_AA:
+ // NearestPixel NormalizingPathIterator:
+ return rdrCtx.nPQPathIterator.init(src);
+ case OFF:
+ // return original path iterator if normalization is disabled:
+ return src;
+ default:
+ throw new InternalError("Unrecognized normalization mode");
+ }
+ }
+
+ abstract static class NormalizingPathIterator implements PathIterator {
+
+ private PathIterator src;
+
+ // the adjustment applied to the current position.
+ private float curx_adjust, cury_adjust;
+ // the adjustment applied to the last moveTo position.
+ private float movx_adjust, movy_adjust;
+
+ private final float[] tmp;
+
+ NormalizingPathIterator(final float[] tmp) {
+ this.tmp = tmp;
+ }
+
+ final NormalizingPathIterator init(final PathIterator src) {
+ this.src = src;
+ return this; // fluent API
+ }
+
+ /**
+ * Disposes this path iterator:
+ * clean up before reusing this instance
+ */
+ final void dispose() {
+ // free source PathIterator:
+ this.src = null;
+ }
+
+ @Override
+ public final int currentSegment(final float[] coords) {
+ if (doMonitors) {
+ RendererContext.stats.mon_npi_currentSegment.start();
+ }
+ int lastCoord;
+ final int type = src.currentSegment(coords);
+
+ switch(type) {
+ case PathIterator.SEG_MOVETO:
+ case PathIterator.SEG_LINETO:
+ lastCoord = 0;
+ break;
+ case PathIterator.SEG_QUADTO:
+ lastCoord = 2;
+ break;
+ case PathIterator.SEG_CUBICTO:
+ lastCoord = 4;
+ break;
+ case PathIterator.SEG_CLOSE:
+ // we don't want to deal with this case later. We just exit now
+ curx_adjust = movx_adjust;
+ cury_adjust = movy_adjust;
+
+ if (doMonitors) {
+ RendererContext.stats.mon_npi_currentSegment.stop();
+ }
+ return type;
+ default:
+ throw new InternalError("Unrecognized curve type");
+ }
+
+ // TODO: handle NaN, Inf and overflow
+
+ // normalize endpoint
+ float coord, x_adjust, y_adjust;
+
+ coord = coords[lastCoord];
+ x_adjust = normCoord(coord); // new coord
+ coords[lastCoord] = x_adjust;
+ x_adjust -= coord;
+
+ coord = coords[lastCoord + 1];
+ y_adjust = normCoord(coord); // new coord
+ coords[lastCoord + 1] = y_adjust;
+ y_adjust -= coord;
+
+ // now that the end points are done, normalize the control points
+ switch(type) {
+ case PathIterator.SEG_MOVETO:
+ movx_adjust = x_adjust;
+ movy_adjust = y_adjust;
+ break;
+ case PathIterator.SEG_LINETO:
+ break;
+ case PathIterator.SEG_QUADTO:
+ coords[0] += (curx_adjust + x_adjust) / 2f;
+ coords[1] += (cury_adjust + y_adjust) / 2f;
+ break;
+ case PathIterator.SEG_CUBICTO:
+ coords[0] += curx_adjust;
+ coords[1] += cury_adjust;
+ coords[2] += x_adjust;
+ coords[3] += y_adjust;
+ break;
+ case PathIterator.SEG_CLOSE:
+ // handled earlier
+ default:
+ }
+ curx_adjust = x_adjust;
+ cury_adjust = y_adjust;
+
+ if (doMonitors) {
+ RendererContext.stats.mon_npi_currentSegment.stop();
+ }
+ return type;
+ }
+
+ abstract float normCoord(final float coord);
+
+ @Override
+ public final int currentSegment(final double[] coords) {
+ final float[] _tmp = tmp; // dirty
+ int type = this.currentSegment(_tmp);
+ for (int i = 0; i < 6; i++) {
+ coords[i] = _tmp[i];
+ }
+ return type;
+ }
+
+ @Override
+ public final int getWindingRule() {
+ return src.getWindingRule();
+ }
+
+ @Override
+ public final boolean isDone() {
+ if (src.isDone()) {
+ // Dispose this instance:
+ dispose();
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public final void next() {
+ src.next();
+ }
+
+ static final class NearestPixelCenter
+ extends NormalizingPathIterator
+ {
+ NearestPixelCenter(final float[] tmp) {
+ super(tmp);
+ }
+
+ @Override
+ float normCoord(final float coord) {
+ // round to nearest pixel center
+ return FloatMath.floor_f(coord) + 0.5f;
+ }
+ }
+
+ static final class NearestPixelQuarter
+ extends NormalizingPathIterator
+ {
+ NearestPixelQuarter(final float[] tmp) {
+ super(tmp);
+ }
+
+ @Override
+ float normCoord(final float coord) {
+ // round to nearest (0.25, 0.25) pixel quarter
+ return FloatMath.floor_f(coord + 0.25f) + 0.25f;
+ }
+ }
+ }
+
+ private static void pathTo(final RendererContext rdrCtx, final PathIterator pi,
+ final PathConsumer2D pc2d)
+ {
+ // mark context as DIRTY:
+ rdrCtx.dirty = true;
+
+ final float[] coords = rdrCtx.float6;
+
+ pathToLoop(coords, pi, pc2d);
+
+ // mark context as CLEAN:
+ rdrCtx.dirty = false;
+ }
+
+ private static void pathToLoop(final float[] coords, final PathIterator pi,
+ final PathConsumer2D pc2d)
+ {
+ for (; !pi.isDone(); pi.next()) {
+ switch (pi.currentSegment(coords)) {
+ case PathIterator.SEG_MOVETO:
+ pc2d.moveTo(coords[0], coords[1]);
+ continue;
+ case PathIterator.SEG_LINETO:
+ pc2d.lineTo(coords[0], coords[1]);
+ continue;
+ case PathIterator.SEG_QUADTO:
+ pc2d.quadTo(coords[0], coords[1],
+ coords[2], coords[3]);
+ continue;
+ case PathIterator.SEG_CUBICTO:
+ pc2d.curveTo(coords[0], coords[1],
+ coords[2], coords[3],
+ coords[4], coords[5]);
+ continue;
+ case PathIterator.SEG_CLOSE:
+ pc2d.closePath();
+ continue;
+ default:
+ }
+ }
+ pc2d.pathDone();
+ }
+
+ /**
+ * Construct an antialiased tile generator for the given shape with
+ * the given rendering attributes and store the bounds of the tile
+ * iteration in the bbox parameter.
+ * The {@code at} parameter specifies a transform that should affect
+ * both the shape and the {@code BasicStroke} attributes.
+ * The {@code clip} parameter specifies the current clip in effect
+ * in device coordinates and can be used to prune the data for the
+ * operation, but the renderer is not required to perform any
+ * clipping.
+ * If the {@code BasicStroke} parameter is null then the shape
+ * should be filled as is, otherwise the attributes of the
+ * {@code BasicStroke} should be used to specify a draw operation.
+ * The {@code thin} parameter indicates whether or not the
+ * transformed {@code BasicStroke} represents coordinates smaller
+ * than the minimum resolution of the antialiasing rasterizer as
+ * specified by the {@code getMinimumAAPenWidth()} method.
+ *
+ * Upon returning, this method will fill the {@code bbox} parameter
+ * with 4 values indicating the bounds of the iteration of the
+ * tile generator.
+ * The iteration order of the tiles will be as specified by the
+ * pseudo-code:
+ *
+ * for (y = bbox[1]; y < bbox[3]; y += tileheight) {
+ * for (x = bbox[0]; x < bbox[2]; x += tilewidth) {
+ * }
+ * }
+ *
+ * If there is no output to be rendered, this method may return
+ * null.
+ *
+ * @param s the shape to be rendered (fill or draw)
+ * @param at the transform to be applied to the shape and the
+ * stroke attributes
+ * @param clip the current clip in effect in device coordinates
+ * @param bs if non-null, a {@code BasicStroke} whose attributes
+ * should be applied to this operation
+ * @param thin true if the transformed stroke attributes are smaller
+ * than the minimum dropout pen width
+ * @param normalize true if the {@code VALUE_STROKE_NORMALIZE}
+ * {@code RenderingHint} is in effect
+ * @param bbox returns the bounds of the iteration
+ * @return the {@code AATileGenerator} instance to be consulted
+ * for tile coverages, or null if there is no output to render
+ * @since 1.7
+ */
+ @Override
+ public AATileGenerator getAATileGenerator(Shape s,
+ AffineTransform at,
+ Region clip,
+ BasicStroke bs,
+ boolean thin,
+ boolean normalize,
+ int bbox[])
+ {
+ MarlinTileGenerator ptg = null;
+ Renderer r = null;
+
+ final RendererContext rdrCtx = getRendererContext();
+ try {
+ // Test if at is identity:
+ final AffineTransform _at = (at != null && !at.isIdentity()) ? at
+ : null;
+
+ final NormMode norm = (normalize) ? NormMode.ON_WITH_AA : NormMode.OFF;
+
+ if (bs == null) {
+ // fill shape:
+ final PathIterator pi = getNormalizingPathIterator(rdrCtx, norm,
+ s.getPathIterator(_at));
+
+ r = rdrCtx.renderer.init(clip.getLoX(), clip.getLoY(),
+ clip.getWidth(), clip.getHeight(),
+ pi.getWindingRule());
+
+ // TODO: subdivide quad/cubic curves into monotonic curves ?
+ pathTo(rdrCtx, pi, r);
+ } else {
+ // draw shape with given stroke:
+ r = rdrCtx.renderer.init(clip.getLoX(), clip.getLoY(),
+ clip.getWidth(), clip.getHeight(),
+ PathIterator.WIND_NON_ZERO);
+
+ strokeTo(rdrCtx, s, _at, bs, thin, norm, true, r);
+ }
+ if (r.endRendering()) {
+ ptg = rdrCtx.ptg.init();
+ ptg.getBbox(bbox);
+ // note: do not returnRendererContext(rdrCtx)
+ // as it will be called later by MarlinTileGenerator.dispose()
+ r = null;
+ }
+ } finally {
+ if (r != null) {
+ // dispose renderer:
+ r.dispose();
+ // recycle the RendererContext instance
+ MarlinRenderingEngine.returnRendererContext(rdrCtx);
+ }
+ }
+
+ // Return null to cancel AA tile generation (nothing to render)
+ return ptg;
+ }
+
+ @Override
+ public final AATileGenerator getAATileGenerator(double x, double y,
+ double dx1, double dy1,
+ double dx2, double dy2,
+ double lw1, double lw2,
+ Region clip,
+ int bbox[])
+ {
+ // REMIND: Deal with large coordinates!
+ double ldx1, ldy1, ldx2, ldy2;
+ boolean innerpgram = (lw1 > 0.0 && lw2 > 0.0);
+
+ if (innerpgram) {
+ ldx1 = dx1 * lw1;
+ ldy1 = dy1 * lw1;
+ ldx2 = dx2 * lw2;
+ ldy2 = dy2 * lw2;
+ x -= (ldx1 + ldx2) / 2.0;
+ y -= (ldy1 + ldy2) / 2.0;
+ dx1 += ldx1;
+ dy1 += ldy1;
+ dx2 += ldx2;
+ dy2 += ldy2;
+ if (lw1 > 1.0 && lw2 > 1.0) {
+ // Inner parallelogram was entirely consumed by stroke...
+ innerpgram = false;
+ }
+ } else {
+ ldx1 = ldy1 = ldx2 = ldy2 = 0.0;
+ }
+
+ MarlinTileGenerator ptg = null;
+ Renderer r = null;
+
+ final RendererContext rdrCtx = getRendererContext();
+ try {
+ r = rdrCtx.renderer.init(clip.getLoX(), clip.getLoY(),
+ clip.getWidth(), clip.getHeight(),
+ Renderer.WIND_EVEN_ODD);
+
+ r.moveTo((float) x, (float) y);
+ r.lineTo((float) (x+dx1), (float) (y+dy1));
+ r.lineTo((float) (x+dx1+dx2), (float) (y+dy1+dy2));
+ r.lineTo((float) (x+dx2), (float) (y+dy2));
+ r.closePath();
+
+ if (innerpgram) {
+ x += ldx1 + ldx2;
+ y += ldy1 + ldy2;
+ dx1 -= 2.0 * ldx1;
+ dy1 -= 2.0 * ldy1;
+ dx2 -= 2.0 * ldx2;
+ dy2 -= 2.0 * ldy2;
+ r.moveTo((float) x, (float) y);
+ r.lineTo((float) (x+dx1), (float) (y+dy1));
+ r.lineTo((float) (x+dx1+dx2), (float) (y+dy1+dy2));
+ r.lineTo((float) (x+dx2), (float) (y+dy2));
+ r.closePath();
+ }
+ r.pathDone();
+
+ if (r.endRendering()) {
+ ptg = rdrCtx.ptg.init();
+ ptg.getBbox(bbox);
+ // note: do not returnRendererContext(rdrCtx)
+ // as it will be called later by MarlinTileGenerator.dispose()
+ r = null;
+ }
+ } finally {
+ if (r != null) {
+ // dispose renderer:
+ r.dispose();
+ // recycle the RendererContext instance
+ MarlinRenderingEngine.returnRendererContext(rdrCtx);
+ }
+ }
+
+ // Return null to cancel AA tile generation (nothing to render)
+ return ptg;
+ }
+
+ /**
+ * Returns the minimum pen width that the antialiasing rasterizer
+ * can represent without dropouts occuring.
+ * @since 1.7
+ */
+ @Override
+ public float getMinimumAAPenSize() {
+ return MIN_PEN_SIZE;
+ }
+
+ static {
+ if (PathIterator.WIND_NON_ZERO != Renderer.WIND_NON_ZERO ||
+ PathIterator.WIND_EVEN_ODD != Renderer.WIND_EVEN_ODD ||
+ BasicStroke.JOIN_MITER != Stroker.JOIN_MITER ||
+ BasicStroke.JOIN_ROUND != Stroker.JOIN_ROUND ||
+ BasicStroke.JOIN_BEVEL != Stroker.JOIN_BEVEL ||
+ BasicStroke.CAP_BUTT != Stroker.CAP_BUTT ||
+ BasicStroke.CAP_ROUND != Stroker.CAP_ROUND ||
+ BasicStroke.CAP_SQUARE != Stroker.CAP_SQUARE)
+ {
+ throw new InternalError("mismatched renderer constants");
+ }
+ }
+
+ // --- RendererContext handling ---
+ // use ThreadLocal or ConcurrentLinkedQueue to get one RendererContext
+ private static final boolean useThreadLocal;
+
+ // hard reference
+ static final int REF_HARD = 0;
+ // soft reference
+ static final int REF_SOFT = 1;
+ // weak reference
+ static final int REF_WEAK = 2;
+
+ // reference type stored in either TL or CLQ
+ static final int REF_TYPE;
+
+ // Per-thread RendererContext
+ private static final ThreadLocal