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.DMarlinRenderingEngine.NormalizingPathIterator;
34
35 /**
36 * This class is a renderer context dedicated to a single thread
37 */
38 final class DRendererContext 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 DRendererContext createContext() {
49 return new DRendererContext("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 double[] double6 = new double[6];
59 // shared curve (dirty) (Renderer / Stroker)
60 final DCurve curve = new DCurve();
61 // MarlinRenderingEngine NormalizingPathIterator NearestPixelCenter:
62 final NormalizingPathIterator nPCPathIterator;
63 // MarlinRenderingEngine NearestPixelQuarter NormalizingPathIterator:
64 final NormalizingPathIterator nPQPathIterator;
65 // MarlinRenderingEngine.TransformingPathConsumer2D
66 final DTransformingPathConsumer2D transformerPC2D;
67 // recycled Path2D instance (weak)
68 private WeakReference<Path2D.Double> refPath2D = null;
69 final DRenderer renderer;
70 final DStroker stroker;
71 // Simplifies out collinear lines
72 final DCollinearSimplifier simplifier = new DCollinearSimplifier();
73 final DDasher 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
79 // Array caches:
80 /* clean int[] cache (zero-filled) = 5 refs */
81 private final IntArrayCache cleanIntCache = new IntArrayCache(true, 5);
82 /* dirty int[] cache = 4 refs */
83 private final IntArrayCache dirtyIntCache = new IntArrayCache(false, 4);
84 /* dirty double[] cache = 3 refs */
85 private final DoubleArrayCache dirtyDoubleCache = new DoubleArrayCache(false, 3);
86 /* dirty byte[] cache = 1 ref */
87 private final ByteArrayCache dirtyByteCache = new ByteArrayCache(false, 1);
88
89 // RendererContext statistics
90 final RendererStats stats;
91
92 final PathConsumer2DAdapter p2dAdapter = new PathConsumer2DAdapter();
93
94
95 /**
96 * Constructor
97 *
98 * @param name context name (debugging)
99 */
100 DRendererContext(final String name) {
101 if (LOG_CREATE_CONTEXT) {
102 MarlinUtils.logInfo("new RendererContext = " + name);
103 }
104 this.cleanerObj = new Object();
105
106 // create first stats (needed by newOffHeapArray):
107 if (DO_STATS || DO_MONITORS) {
108 stats = RendererStats.createInstance(cleanerObj, name);
109 // push cache stats:
110 stats.cacheStats = new CacheStats[] { cleanIntCache.stats,
111 dirtyIntCache.stats, dirtyDoubleCache.stats, dirtyByteCache.stats
112 };
113 } else {
114 stats = null;
115 }
116
117 // NormalizingPathIterator instances:
118 nPCPathIterator = new NormalizingPathIterator.NearestPixelCenter(double6);
119 nPQPathIterator = new NormalizingPathIterator.NearestPixelQuarter(double6);
120
121 // MarlinRenderingEngine.TransformingPathConsumer2D
122 transformerPC2D = new DTransformingPathConsumer2D();
123
124 // Renderer:
125 cache = new MarlinCache(this);
126 renderer = new DRenderer(this); // needs MarlinCache from rdrCtx.cache
127 ptg = new MarlinTileGenerator(stats, renderer, cache);
128
129 stroker = new DStroker(this);
130 dasher = new DDasher(this);
131 }
132
133 /**
134 * Disposes this renderer context:
135 * clean up before reusing this context
136 */
137 void dispose() {
138 if (DO_STATS) {
139 if (stats.totalOffHeap > stats.totalOffHeapMax) {
140 stats.totalOffHeapMax = stats.totalOffHeap;
141 }
142 stats.totalOffHeap = 0L;
143 }
144 stroking = 0;
145 // if context is maked as DIRTY:
146 if (dirty) {
147 // may happen if an exception if thrown in the pipeline processing:
148 // force cleanup of all possible pipelined blocks (except Renderer):
149
150 // NormalizingPathIterator instances:
151 this.nPCPathIterator.dispose();
152 this.nPQPathIterator.dispose();
153 // Dasher:
154 this.dasher.dispose();
155 // Stroker:
156 this.stroker.dispose();
157
158 // mark context as CLEAN:
159 dirty = false;
160 }
161 }
162
163 Path2D.Double getPath2D() {
164 // resolve reference:
165 Path2D.Double p2d
166 = (refPath2D != null) ? refPath2D.get() : null;
167
168 // create a new Path2D ?
169 if (p2d == null) {
170 p2d = new Path2D.Double(Path2D.WIND_NON_ZERO, INITIAL_EDGES_COUNT); // 32K
171
172 // update weak reference:
173 refPath2D = new WeakReference<Path2D.Double>(p2d);
174 }
175 // reset the path anyway:
176 p2d.reset();
177 return p2d;
178 }
179
180 @Override
181 public RendererStats stats() {
182 return stats;
183 }
184
185 @Override
186 public OffHeapArray newOffHeapArray(final long initialSize) {
187 if (DO_STATS) {
188 stats.totalOffHeapInitial += initialSize;
189 }
190 return new OffHeapArray(cleanerObj, initialSize);
191 }
192
193 @Override
194 public IntArrayCache.Reference newCleanIntArrayRef(final int initialSize) {
195 return cleanIntCache.createRef(initialSize);
196 }
197
198 IntArrayCache.Reference newDirtyIntArrayRef(final int initialSize) {
199 return dirtyIntCache.createRef(initialSize);
200 }
201
202 DoubleArrayCache.Reference newDirtyDoubleArrayRef(final int initialSize) {
203 return dirtyDoubleCache.createRef(initialSize);
204 }
205
206 ByteArrayCache.Reference newDirtyByteArrayRef(final int initialSize) {
207 return dirtyByteCache.createRef(initialSize);
208 }
209
210 static final class PathConsumer2DAdapter implements DPathConsumer2D {
211 private sun.awt.geom.PathConsumer2D out;
212
213 PathConsumer2DAdapter() {}
214
215 PathConsumer2DAdapter init(sun.awt.geom.PathConsumer2D out) {
216 this.out = out;
217 return this;
218 }
219
220 @Override
221 public void moveTo(double x0, double y0) {
222 out.moveTo((float)x0, (float)y0);
223 }
224
225 @Override
226 public void lineTo(double x1, double y1) {
227 out.lineTo((float)x1, (float)y1);
228 }
229
230 @Override
231 public void closePath() {
232 out.closePath();
233 }
234
235 @Override
236 public void pathDone() {
237 out.pathDone();
238 }
239
240 @Override
241 public void curveTo(double x1, double y1,
242 double x2, double y2,
243 double x3, double y3)
244 {
245 out.curveTo((float)x1, (float)y1,
246 (float)x2, (float)y2,
247 (float)x3, (float)y3);
248 }
249
250 @Override
251 public void quadTo(double x1, double y1, double x2, double y2) {
252 out.quadTo((float)x1, (float)y1, (float)x2, (float)y2);
253 }
254
255 @Override
256 public long getNativeConsumer() {
257 throw new InternalError("Not using a native peer");
258 }
259 }
260 }
--- EOF ---