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      */
createContext()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     // clip inverse scale (mean) to adjust length checks
89     float clipInvScale = 0.0f;
90     // CurveBasicMonotonizer instance
91     final CurveBasicMonotonizer monotonizer;
92     // CurveClipSplitter instance
93     final CurveClipSplitter curveClipSplitter;
94 
95     // Array caches:
96     /* clean int[] cache (zero-filled) = 5 refs */
97     private final IntArrayCache cleanIntCache = new IntArrayCache(true, 5);
98     /* dirty int[] cache = 5 refs */
99     private final IntArrayCache dirtyIntCache = new IntArrayCache(false, 5);
100     /* dirty float[] cache = 4 refs (2 polystack) */
101     private final FloatArrayCache dirtyFloatCache = new FloatArrayCache(false, 4);
102     /* dirty byte[] cache = 2 ref (2 polystack) */
103     private final ByteArrayCache dirtyByteCache = new ByteArrayCache(false, 2);
104 
105     // RendererContext statistics
106     final RendererStats stats;
107 
108     /**
109      * Constructor
110      *
111      * @param name context name (debugging)
112      */
RendererContext(final String name)113     RendererContext(final String name) {
114         if (LOG_CREATE_CONTEXT) {
115             MarlinUtils.logInfo("new RendererContext = " + name);
116         }
117         this.cleanerObj = new Object();
118 
119         // create first stats (needed by newOffHeapArray):
120         if (DO_STATS || DO_MONITORS) {
121             stats = RendererStats.createInstance(cleanerObj, name);
122             // push cache stats:
123             stats.cacheStats = new CacheStats[] { cleanIntCache.stats,
124                 dirtyIntCache.stats, dirtyFloatCache.stats, dirtyByteCache.stats
125             };
126         } else {
127             stats = null;
128         }
129 
130         // NormalizingPathIterator instances:
131         nPCPathIterator = new NormalizingPathIterator.NearestPixelCenter(float6);
132         nPQPathIterator  = new NormalizingPathIterator.NearestPixelQuarter(float6);
133 
134         // curve monotonizer & clip subdivider (before transformerPC2D init)
135         monotonizer = new CurveBasicMonotonizer(this);
136         curveClipSplitter = new CurveClipSplitter(this);
137 
138         // MarlinRenderingEngine.TransformingPathConsumer2D
139         transformerPC2D = new TransformingPathConsumer2D(this);
140 
141         // Renderer:
142         cache = new MarlinCache(this);
143         renderer = new Renderer(this); // needs MarlinCache from rdrCtx.cache
144         ptg = new MarlinTileGenerator(stats, renderer, cache);
145 
146         stroker = new Stroker(this);
147         dasher = new Dasher(this);
148     }
149 
150     /**
151      * Disposes this renderer context:
152      * clean up before reusing this context
153      */
dispose()154     void dispose() {
155         if (DO_STATS) {
156             if (stats.totalOffHeap > stats.totalOffHeapMax) {
157                 stats.totalOffHeapMax = stats.totalOffHeap;
158             }
159             stats.totalOffHeap = 0L;
160         }
161         stroking   = 0;
162         doClip     = false;
163         closedPath = false;
164         clipInvScale = 0.0f;
165 
166         // if context is maked as DIRTY:
167         if (dirty) {
168             // may happen if an exception if thrown in the pipeline processing:
169             // force cleanup of all possible pipelined blocks (except Renderer):
170 
171             // NormalizingPathIterator instances:
172             this.nPCPathIterator.dispose();
173             this.nPQPathIterator.dispose();
174             // Dasher:
175             this.dasher.dispose();
176             // Stroker:
177             this.stroker.dispose();
178 
179             // mark context as CLEAN:
180             dirty = false;
181         }
182     }
183 
getPath2D()184     Path2D.Float getPath2D() {
185         // resolve reference:
186         Path2D.Float p2d = (refPath2D != null) ? refPath2D.get() : null;
187 
188         // create a new Path2D ?
189         if (p2d == null) {
190             p2d = new Path2D.Float(WIND_NON_ZERO, INITIAL_EDGES_COUNT); // 32K
191 
192             // update weak reference:
193             refPath2D = new WeakReference<Path2D.Float>(p2d);
194         }
195         // reset the path anyway:
196         p2d.reset();
197         return p2d;
198     }
199 
200     @Override
stats()201     public RendererStats stats() {
202         return stats;
203     }
204 
205     @Override
newOffHeapArray(final long initialSize)206     public OffHeapArray newOffHeapArray(final long initialSize) {
207         if (DO_STATS) {
208             stats.totalOffHeapInitial += initialSize;
209         }
210         return new OffHeapArray(cleanerObj, initialSize);
211     }
212 
213     @Override
newCleanIntArrayRef(final int initialSize)214     public IntArrayCache.Reference newCleanIntArrayRef(final int initialSize) {
215         return cleanIntCache.createRef(initialSize);
216     }
217 
newDirtyIntArrayRef(final int initialSize)218     IntArrayCache.Reference newDirtyIntArrayRef(final int initialSize) {
219         return dirtyIntCache.createRef(initialSize);
220     }
221 
newDirtyFloatArrayRef(final int initialSize)222     FloatArrayCache.Reference newDirtyFloatArrayRef(final int initialSize) {
223         return dirtyFloatCache.createRef(initialSize);
224     }
225 
newDirtyByteArrayRef(final int initialSize)226     ByteArrayCache.Reference newDirtyByteArrayRef(final int initialSize) {
227         return dirtyByteCache.createRef(initialSize);
228     }
229 }
230