jdk-sandbox: comparison jdk/src/java.desktop/share/classes/sun/java2d/marlin/MarlinRenderingEngine.java

equal deleted inserted replaced

-:cf5567d544b4
+:21bfc4452441
 public Shape createStrokedShape(Shape src,
 float width,
 int caps,
 int join,
 float miterlimit,
-float dashes[],
+float[] dashes,
 float dashphase)
 {
 final RendererContext rdrCtx = getRendererContext();
 try {
 // initialize a large copyable Path2D to avoid a lot of array growing:
 float width,
 NormMode normalize,
 int caps,
 int join,
 float miterlimit,
-float dashes[],
+float[] dashes,
 float dashphase,
 PathConsumer2D pc2d)
 {
 // We use strokerat so that in Stroker and Dasher we can work only
 // with the pre-transformation coordinates. This will repeat a lot of
 dashLen = dashes.length;
 final float[] newDashes;
 if (dashLen <= INITIAL_ARRAY) {
 newDashes = rdrCtx.dasher.dashes_initial;
 } else {
-if (doStats) {
+if (DO_STATS) {
-RendererContext.stats.stat_array_dasher_dasher
+rdrCtx.stats.stat_array_dasher_dasher
 .add(dashLen);
 }
 newDashes = rdrCtx.getDirtyFloatArray(dashLen);
 }
 System.arraycopy(dashes, 0, newDashes, 0, dashLen);
 // either at is null or it's the identity. In either case
 // we don't transform the path.
 at = null;
 }
-if (useSimplifier) {
+if (USE_SIMPLIFIER) {
 // Use simplifier after stroker before Renderer
 // to remove collinear segments (notably due to cap square)
 pc2d = rdrCtx.simplifier.init(pc2d);
 }
 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:
 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];
 // 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);
 AffineTransform at,
 Region clip,
 BasicStroke bs,
 boolean thin,
 boolean normalize,
-int bbox[])
+int[] bbox)
 {
 MarlinTileGenerator ptg = null;
 Renderer r = null;
 final RendererContext rdrCtx = getRendererContext();
 if (bs == null) {
 // fill shape:
 final PathIterator pi = getNormalizingPathIterator(rdrCtx, norm,
 s.getPathIterator(_at));
+// note: Winding rule may be EvenOdd ONLY for fill operations !
 r = rdrCtx.renderer.init(clip.getLoX(), clip.getLoY(),
 clip.getWidth(), clip.getHeight(),
 pi.getWindingRule());
 // TODO: subdivide quad/cubic curves into monotonic curves ?
 public final AATileGenerator getAATileGenerator(double x, double y,
 double dx1, double dy1,
 double dx2, double dy2,
 double lw1, double lw2,
 Region clip,
-int bbox[])
+int[] bbox)
 {
 // REMIND: Deal with large coordinates!
 double ldx1, ldy1, ldx2, ldy2;
 boolean innerpgram = (lw1 > 0.0 && lw2 > 0.0);
 }
 }
 // --- RendererContext handling ---
 // use ThreadLocal or ConcurrentLinkedQueue to get one RendererContext
-private static final boolean useThreadLocal;
+private static final boolean USE_THREAD_LOCAL;
 // reference type stored in either TL or CLQ
 static final int REF_TYPE;
 // Per-thread RendererContext
-private static final ReentrantContextProvider<RendererContext> rdrCtxProvider;
+private static final ReentrantContextProvider<RendererContext> RDR_CTX_PROVIDER;
 // Static initializer to use TL or CLQ mode
 static {
-useThreadLocal = MarlinProperties.isUseThreadLocal();
+USE_THREAD_LOCAL = MarlinProperties.isUseThreadLocal();
 // Soft reference by default:
 final String refType = AccessController.doPrivileged(
 new GetPropertyAction("sun.java2d.renderer.useRef",
 "soft"));
 case "hard":
 REF_TYPE = ReentrantContextProvider.REF_HARD;
 break;
 }
-if (useThreadLocal) {
+if (USE_THREAD_LOCAL) {
-rdrCtxProvider = new ReentrantContextProviderTL<RendererContext>(REF_TYPE)
+RDR_CTX_PROVIDER = new ReentrantContextProviderTL<RendererContext>(REF_TYPE)
 {
 @Override
 protected RendererContext newContext() {
 return RendererContext.createContext();
 }
 };
 } else {
-rdrCtxProvider = new ReentrantContextProviderCLQ<RendererContext>(REF_TYPE)
+RDR_CTX_PROVIDER = new ReentrantContextProviderCLQ<RendererContext>(REF_TYPE)
 {
 @Override
 protected RendererContext newContext() {
 return RendererContext.createContext();
 }
 };
 }
 }
-private static boolean settingsLogged = !enableLogs;
+private static boolean SETTINGS_LOGGED = !ENABLE_LOGS;
 private static void logSettings(final String reClass) {
 // log information at startup
-if (settingsLogged) {
+if (SETTINGS_LOGGED) {
 return;
 }
-settingsLogged = true;
+SETTINGS_LOGGED = true;
 String refType;
 switch (REF_TYPE) {
 default:
 case ReentrantContextProvider.REF_HARD:
 logInfo("Version                              = ["
 + Version.getVersion() + "]");
 logInfo("sun.java2d.renderer                  = "
 + reClass);
 logInfo("sun.java2d.renderer.useThreadLocal   = "
-+ useThreadLocal);
++ USE_THREAD_LOCAL);
 logInfo("sun.java2d.renderer.useRef           = "
 + refType);
 logInfo("sun.java2d.renderer.pixelsize        = "
 + MarlinConst.INITIAL_PIXEL_DIM);
 logInfo("sun.java2d.renderer.rleMinWidth      = "
 + MarlinCache.RLE_MIN_WIDTH);
 // optimisation parameters
 logInfo("sun.java2d.renderer.useSimplifier    = "
-+ MarlinConst.useSimplifier);
++ MarlinConst.USE_SIMPLIFIER);
 // debugging parameters
 logInfo("sun.java2d.renderer.doStats          = "
-+ MarlinConst.doStats);
++ MarlinConst.DO_STATS);
 logInfo("sun.java2d.renderer.doMonitors       = "
-+ MarlinConst.doMonitors);
++ MarlinConst.DO_MONITORS);
 logInfo("sun.java2d.renderer.doChecks         = "
-+ MarlinConst.doChecks);
++ MarlinConst.DO_CHECKS);
 // logging parameters
 logInfo("sun.java2d.renderer.useLogger        = "
-+ MarlinConst.useLogger);
++ MarlinConst.USE_LOGGER);
 logInfo("sun.java2d.renderer.logCreateContext = "
-+ MarlinConst.logCreateContext);
++ MarlinConst.LOG_CREATE_CONTEXT);
 logInfo("sun.java2d.renderer.logUnsafeMalloc  = "
-+ MarlinConst.logUnsafeMalloc);
++ MarlinConst.LOG_UNSAFE_MALLOC);
 // quality settings
 logInfo("Renderer settings:");
 logInfo("CUB_COUNT_LG = " + Renderer.CUB_COUNT_LG);
 logInfo("CUB_DEC_BND  = " + Renderer.CUB_DEC_BND);
 * Get the RendererContext instance dedicated to the current thread
 * @return RendererContext instance
 */
 @SuppressWarnings({"unchecked"})
 static RendererContext getRendererContext() {
-final RendererContext rdrCtx = rdrCtxProvider.acquire();
+final RendererContext rdrCtx = RDR_CTX_PROVIDER.acquire();
-if (doMonitors) {
+if (DO_MONITORS) {
-RendererContext.stats.mon_pre_getAATileGenerator.start();
+rdrCtx.stats.mon_pre_getAATileGenerator.start();
 }
 return rdrCtx;
 }
 /**
 * @param rdrCtx RendererContext instance
 */
 static void returnRendererContext(final RendererContext rdrCtx) {
 rdrCtx.dispose();
-if (doMonitors) {
+if (DO_MONITORS) {
-RendererContext.stats.mon_pre_getAATileGenerator.stop();
+rdrCtx.stats.mon_pre_getAATileGenerator.stop();
 }
-rdrCtxProvider.release(rdrCtx);
+RDR_CTX_PROVIDER.release(rdrCtx);
 }
 }

changeset 39519	21bfc4452441
parent 36902	bb30d89aa00e
child 40421	d5ee65e2b0fb