1 /*
2 * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package sun.java2d.marlin;
27
28 import java.awt.geom.Path2D;
29 import java.lang.ref.WeakReference;
30 import java.util.concurrent.atomic.AtomicInteger;
31 import sun.java2d.ReentrantContext;
32 import sun.java2d.marlin.ArrayCacheConst.CacheStats;
33 import sun.java2d.marlin.MarlinRenderingEngine.NormalizingPathIterator;
34
35 /**
36 * This class is a renderer context dedicated to a single thread
37 */
38 final class RendererContext extends ReentrantContext implements IRendererContext {
39
40 // RendererContext creation counter
41 private static final AtomicInteger CTX_COUNT = new AtomicInteger(1);
42
43 /**
44 * Create a new renderer context
45 *
46 * @return new RendererContext instance
47 */
48 static RendererContext createContext() {
49 return new RendererContext("ctx"
50 + Integer.toString(CTX_COUNT.getAndIncrement()));
51 }
52
53 // Smallest object used as Cleaner's parent reference
54 private final Object cleanerObj;
55 // dirty flag indicating an exception occured during pipeline in pathTo()
56 boolean dirty = false;
57 // shared data
58 final float[] float6 = new float[6];
59 // shared curve (dirty) (Renderer / Stroker)
60 final Curve curve = new Curve();
61 // MarlinRenderingEngine NormalizingPathIterator NearestPixelCenter:
62 final NormalizingPathIterator nPCPathIterator;
63 // MarlinRenderingEngine NearestPixelQuarter NormalizingPathIterator:
64 final NormalizingPathIterator nPQPathIterator;
65 // MarlinRenderingEngine.TransformingPathConsumer2D
66 final TransformingPathConsumer2D transformerPC2D;
67 // recycled Path2D instance (weak)
68 private WeakReference<Path2D.Float> refPath2D = null;
69 final Renderer renderer;
70 final Stroker stroker;
71 // Simplifies out collinear lines
72 final CollinearSimplifier simplifier = new CollinearSimplifier();
73 final Dasher dasher;
74 final MarlinTileGenerator ptg;
75 final MarlinCache cache;
76 // flag indicating the shape is stroked (1) or filled (0)
77 int stroking = 0;
78 // flag indicating to clip the shape
79 boolean doClip = false;
80 // flag indicating if the path is closed or not (in advance) to handle properly caps
81 boolean closedPath = false;
82 // clip rectangle (ymin, ymax, xmin, xmax):
83 final float[] clipRect = new float[4];
84
85 // Array caches:
86 /* clean int[] cache (zero-filled) = 5 refs */
87 private final IntArrayCache cleanIntCache = new IntArrayCache(true, 5);
88 /* dirty int[] cache = 5 refs */
89 private final IntArrayCache dirtyIntCache = new IntArrayCache(false, 5);
90 /* dirty float[] cache = 4 refs (2 polystack) */
91 private final FloatArrayCache dirtyFloatCache = new FloatArrayCache(false, 4);
92 /* dirty byte[] cache = 2 ref (2 polystack) */
93 private final ByteArrayCache dirtyByteCache = new ByteArrayCache(false, 2);
94
95 // RendererContext statistics
96 final RendererStats stats;
97
98 /**
99 * Constructor
100 *
101 * @param name context name (debugging)
102 */
103 RendererContext(final String name) {
104 if (LOG_CREATE_CONTEXT) {
105 MarlinUtils.logInfo("new RendererContext = " + name);
106 }
107 this.cleanerObj = new Object();
108
109 // create first stats (needed by newOffHeapArray):
110 if (DO_STATS || DO_MONITORS) {
111 stats = RendererStats.createInstance(cleanerObj, name);
112 // push cache stats:
113 stats.cacheStats = new CacheStats[] { cleanIntCache.stats,
114 dirtyIntCache.stats, dirtyFloatCache.stats, dirtyByteCache.stats
115 };
116 } else {
117 stats = null;
118 }
119
120 // NormalizingPathIterator instances:
121 nPCPathIterator = new NormalizingPathIterator.NearestPixelCenter(float6);
122 nPQPathIterator = new NormalizingPathIterator.NearestPixelQuarter(float6);
123
124 // MarlinRenderingEngine.TransformingPathConsumer2D
125 transformerPC2D = new TransformingPathConsumer2D(this);
126
127 // Renderer:
128 cache = new MarlinCache(this);
129 renderer = new Renderer(this); // needs MarlinCache from rdrCtx.cache
130 ptg = new MarlinTileGenerator(stats, renderer, cache);
131
132 stroker = new Stroker(this);
133 dasher = new Dasher(this);
134 }
135
136 /**
137 * Disposes this renderer context:
138 * clean up before reusing this context
139 */
140 void dispose() {
141 if (DO_STATS) {
142 if (stats.totalOffHeap > stats.totalOffHeapMax) {
|
1 /*
2 * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package sun.java2d.marlin;
27
28 import java.awt.geom.Path2D;
29 import java.lang.ref.WeakReference;
30 import java.util.concurrent.atomic.AtomicInteger;
31 import sun.java2d.ReentrantContext;
32 import sun.java2d.marlin.ArrayCacheConst.CacheStats;
33 import sun.java2d.marlin.MarlinRenderingEngine.NormalizingPathIterator;
34 import sun.java2d.marlin.TransformingPathConsumer2D.CurveBasicMonotonizer;
35 import sun.java2d.marlin.TransformingPathConsumer2D.CurveClipSplitter;
36
37 /**
38 * This class is a renderer context dedicated to a single thread
39 */
40 final class RendererContext extends ReentrantContext implements IRendererContext {
41
42 // RendererContext creation counter
43 private static final AtomicInteger CTX_COUNT = new AtomicInteger(1);
44
45 /**
46 * Create a new renderer context
47 *
48 * @return new RendererContext instance
49 */
50 static RendererContext createContext() {
51 return new RendererContext("ctx"
52 + Integer.toString(CTX_COUNT.getAndIncrement()));
53 }
54
55 // Smallest object used as Cleaner's parent reference
56 private final Object cleanerObj;
57 // dirty flag indicating an exception occured during pipeline in pathTo()
58 boolean dirty = false;
59 // shared data
60 final float[] float6 = new float[6];
61 // shared curve (dirty) (Renderer / Stroker)
62 final Curve curve = new Curve();
63 // MarlinRenderingEngine NormalizingPathIterator NearestPixelCenter:
64 final NormalizingPathIterator nPCPathIterator;
65 // MarlinRenderingEngine NearestPixelQuarter NormalizingPathIterator:
66 final NormalizingPathIterator nPQPathIterator;
67 // MarlinRenderingEngine.TransformingPathConsumer2D
68 final TransformingPathConsumer2D transformerPC2D;
69 // recycled Path2D instance (weak)
70 private WeakReference<Path2D.Float> refPath2D = null;
71 final Renderer renderer;
72 final Stroker stroker;
73 // Simplifies out collinear lines
74 final CollinearSimplifier simplifier = new CollinearSimplifier();
75 // Simplifies path
76 final PathSimplifier pathSimplifier = new PathSimplifier();
77 final Dasher dasher;
78 final MarlinTileGenerator ptg;
79 final MarlinCache cache;
80 // flag indicating the shape is stroked (1) or filled (0)
81 int stroking = 0;
82 // flag indicating to clip the shape
83 boolean doClip = false;
84 // flag indicating if the path is closed or not (in advance) to handle properly caps
85 boolean closedPath = false;
86 // clip rectangle (ymin, ymax, xmin, xmax):
87 final float[] clipRect = new float[4];
88 // CurveBasicMonotonizer instance
89 final CurveBasicMonotonizer monotonizer;
90 // CurveClipSplitter instance
91 final CurveClipSplitter curveClipSplitter;
92
93 // Array caches:
94 /* clean int[] cache (zero-filled) = 5 refs */
95 private final IntArrayCache cleanIntCache = new IntArrayCache(true, 5);
96 /* dirty int[] cache = 5 refs */
97 private final IntArrayCache dirtyIntCache = new IntArrayCache(false, 5);
98 /* dirty float[] cache = 4 refs (2 polystack) */
99 private final FloatArrayCache dirtyFloatCache = new FloatArrayCache(false, 4);
100 /* dirty byte[] cache = 2 ref (2 polystack) */
101 private final ByteArrayCache dirtyByteCache = new ByteArrayCache(false, 2);
102
103 // RendererContext statistics
104 final RendererStats stats;
105
106 /**
107 * Constructor
108 *
109 * @param name context name (debugging)
110 */
111 RendererContext(final String name) {
112 if (LOG_CREATE_CONTEXT) {
113 MarlinUtils.logInfo("new RendererContext = " + name);
114 }
115 this.cleanerObj = new Object();
116
117 // create first stats (needed by newOffHeapArray):
118 if (DO_STATS || DO_MONITORS) {
119 stats = RendererStats.createInstance(cleanerObj, name);
120 // push cache stats:
121 stats.cacheStats = new CacheStats[] { cleanIntCache.stats,
122 dirtyIntCache.stats, dirtyFloatCache.stats, dirtyByteCache.stats
123 };
124 } else {
125 stats = null;
126 }
127
128 // NormalizingPathIterator instances:
129 nPCPathIterator = new NormalizingPathIterator.NearestPixelCenter(float6);
130 nPQPathIterator = new NormalizingPathIterator.NearestPixelQuarter(float6);
131
132 // curve monotonizer & clip subdivider (before transformerPC2D init)
133 monotonizer = new CurveBasicMonotonizer(this);
134 curveClipSplitter = new CurveClipSplitter(this);
135
136 // MarlinRenderingEngine.TransformingPathConsumer2D
137 transformerPC2D = new TransformingPathConsumer2D(this);
138
139 // Renderer:
140 cache = new MarlinCache(this);
141 renderer = new Renderer(this); // needs MarlinCache from rdrCtx.cache
142 ptg = new MarlinTileGenerator(stats, renderer, cache);
143
144 stroker = new Stroker(this);
145 dasher = new Dasher(this);
146 }
147
148 /**
149 * Disposes this renderer context:
150 * clean up before reusing this context
151 */
152 void dispose() {
153 if (DO_STATS) {
154 if (stats.totalOffHeap > stats.totalOffHeapMax) {
|