1 /*
2 * Copyright (c) 2008, 2009, 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 package sun.awt.windows;
26
27 import java.awt.AlphaComposite;
28 import java.awt.Color;
29 import java.awt.Graphics2D;
30 import java.awt.GraphicsConfiguration;
31 import java.awt.Image;
32 import java.awt.Window;
33 import java.awt.image.BufferedImage;
34 import java.awt.image.DataBufferInt;
35 import java.awt.image.VolatileImage;
36 import java.lang.ref.WeakReference;
37 import java.security.AccessController;
38 import sun.awt.image.BufImgSurfaceData;
39 import sun.java2d.DestSurfaceProvider;
40 import sun.java2d.InvalidPipeException;
41 import sun.java2d.Surface;
42 import sun.java2d.pipe.RenderQueue;
43 import sun.java2d.pipe.hw.AccelGraphicsConfig;
44 import sun.java2d.pipe.hw.AccelSurface;
45 import sun.security.action.GetPropertyAction;
46
47 import static java.awt.image.VolatileImage.*;
48 import static java.awt.Transparency.*;
49 import static sun.java2d.pipe.hw.AccelSurface.*;
50 import static sun.java2d.pipe.hw.ContextCapabilities.*;
51
52 /**
53 * This class handles the updates of the non-opaque windows.
54 * The window associated with the peer is updated either given an image or
55 * the window is repainted to an internal buffer which is then used to update
56 * the window.
57 *
58 * Note: this class does not attempt to be thread safe, it is expected to be
59 * called from a single thread (EDT).
60 */
61 public abstract class TranslucentWindowPainter {
62
63 protected Window window;
64 protected WWindowPeer peer;
65
66 // REMIND: we probably would want to remove this later
67 private static final boolean forceOpt =
68 Boolean.valueOf(AccessController.doPrivileged(
69 new GetPropertyAction("sun.java2d.twp.forceopt", "false")));
70 private static final boolean forceSW =
71 Boolean.valueOf(AccessController.doPrivileged(
72 new GetPropertyAction("sun.java2d.twp.forcesw", "false")));
73
74 /**
75 * Creates an instance of the painter for particular peer.
76 */
77 public static TranslucentWindowPainter createInstance(WWindowPeer peer) {
78 GraphicsConfiguration gc = peer.getGraphicsConfiguration();
79 if (!forceSW && gc instanceof AccelGraphicsConfig) {
80 String gcName = gc.getClass().getSimpleName();
81 AccelGraphicsConfig agc = (AccelGraphicsConfig)gc;
82 // this is a heuristic to check that we have a pcix board
83 // (those have higher transfer rate from gpu to cpu)
84 if ((agc.getContextCapabilities().getCaps() & CAPS_PS30) != 0 ||
85 forceOpt)
86 {
87 // we check for name to avoid loading classes unnecessarily if
88 // a pipeline isn't enabled
89 if (gcName.startsWith("D3D")) {
90 return new VIOptD3DWindowPainter(peer);
91 } else if (forceOpt && gcName.startsWith("WGL")) {
92 // on some boards (namely, ATI, even on pcix bus) ogl is
93 // very slow reading pixels back so for now it is disabled
94 // unless forced
95 return new VIOptWGLWindowPainter(peer);
96 }
97 }
98 }
99 return new BIWindowPainter(peer);
100 }
101
102 protected TranslucentWindowPainter(WWindowPeer peer) {
103 this.peer = peer;
104 this.window = (Window)peer.getTarget();
105 }
106
107 /**
108 * Creates (if needed), clears (if requested) and returns the buffer
109 * for this painter.
110 */
111 protected abstract Image getBackBuffer(boolean clear);
112
113 /**
114 * Updates the the window associated with this painter with the contents
115 * of the passed image.
116 * The image can not be null, and NPE will be thrown if it is.
117 */
118 protected abstract boolean update(Image bb);
119
120 /**
121 * Flushes the resources associated with the painter. They will be
122 * recreated as needed.
123 */
124 public abstract void flush();
125
126 /**
127 * Updates the window associated with the painter.
128 *
129 * @param repaint indicates if the window should be completely repainted
130 * to the back buffer using {@link java.awt.Window#paintAll} before update.
131 */
132 public void updateWindow(boolean repaint) {
133 boolean done = false;
134 Image bb = getBackBuffer(repaint);
135 while (!done) {
136 if (repaint) {
137 Graphics2D g = (Graphics2D)bb.getGraphics();
138 try {
139 window.paintAll(g);
140 } finally {
141 g.dispose();
142 }
143 }
144
145 done = update(bb);
146 if (!done) {
147 repaint = true;
148 bb = getBackBuffer(true);
149 }
150 }
151 }
152
153 private static final Image clearImage(Image bb) {
154 Graphics2D g = (Graphics2D)bb.getGraphics();
155 int w = bb.getWidth(null);
156 int h = bb.getHeight(null);
157
158 g.setComposite(AlphaComposite.Src);
159 g.setColor(new Color(0, 0, 0, 0));
160 g.fillRect(0, 0, w, h);
161
162 return bb;
163 }
164
165 /**
166 * A painter which uses BufferedImage as the internal buffer. The window
167 * is painted into this buffer, and the contents then are uploaded
168 * into the layered window.
169 *
170 * This painter handles all types of images passed to its paint(Image)
171 * method (VI, BI, regular Images).
172 */
173 private static class BIWindowPainter extends TranslucentWindowPainter {
174 private BufferedImage backBuffer;
175
176 protected BIWindowPainter(WWindowPeer peer) {
177 super(peer);
178 }
179
180 @Override
181 protected Image getBackBuffer(boolean clear) {
182 int w = window.getWidth();
183 int h = window.getHeight();
184 if (backBuffer == null ||
185 backBuffer.getWidth() != w ||
186 backBuffer.getHeight() != h)
187 {
188 flush();
189 backBuffer = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB_PRE);
190 }
191 return clear ? (BufferedImage)clearImage(backBuffer) : backBuffer;
192 }
193
194 @Override
195 protected boolean update(Image bb) {
196 VolatileImage viBB = null;
197
198 if (bb instanceof BufferedImage) {
199 BufferedImage bi = (BufferedImage)bb;
200 int data[] =
201 ((DataBufferInt)bi.getRaster().getDataBuffer()).getData();
202 peer.updateWindowImpl(data, bi.getWidth(), bi.getHeight());
203 return true;
204 } else if (bb instanceof VolatileImage) {
205 viBB = (VolatileImage)bb;
206 if (bb instanceof DestSurfaceProvider) {
207 Surface s = ((DestSurfaceProvider)bb).getDestSurface();
208 if (s instanceof BufImgSurfaceData) {
209 // the image is probably lost, upload the data from the
210 // backup surface to avoid creating another heap-based
211 // image (the parent's buffer)
212 int w = viBB.getWidth();
213 int h = viBB.getHeight();
214 BufImgSurfaceData bisd = (BufImgSurfaceData)s;
215 int data[] = ((DataBufferInt)bisd.getRaster(0,0,w,h).
216 getDataBuffer()).getData();
217 peer.updateWindowImpl(data, w, h);
218 return true;
219 }
220 }
221 }
222
223 // copy the passed image into our own buffer, then upload
224 BufferedImage bi = (BufferedImage)clearImage(backBuffer);
225
226 int data[] =
227 ((DataBufferInt)bi.getRaster().getDataBuffer()).getData();
228 peer.updateWindowImpl(data, bi.getWidth(), bi.getHeight());
229
230 return (viBB != null ? !viBB.contentsLost() : true);
231 }
232
233 public void flush() {
234 if (backBuffer != null) {
235 backBuffer.flush();
236 backBuffer = null;
237 }
238 }
239 }
240
241 /**
242 * A version of the painter which uses VolatileImage as the internal buffer.
243 * The window is painted into this VI and then copied into the parent's
244 * Java heap-based buffer (which is then uploaded to the layered window)
245 */
246 private static class VIWindowPainter extends BIWindowPainter {
247 private VolatileImage viBB;
248
249 protected VIWindowPainter(WWindowPeer peer) {
250 super(peer);
251 }
252
253 @Override
254 protected Image getBackBuffer(boolean clear) {
255 int w = window.getWidth();
256 int h = window.getHeight();
257 GraphicsConfiguration gc = peer.getGraphicsConfiguration();
258
259 if (viBB == null || viBB.getWidth() != w || viBB.getHeight() != h ||
260 viBB.validate(gc) == IMAGE_INCOMPATIBLE)
261 {
262 flush();
263
264 if (gc instanceof AccelGraphicsConfig) {
265 AccelGraphicsConfig agc = ((AccelGraphicsConfig)gc);
266 viBB = agc.createCompatibleVolatileImage(w, h,
267 TRANSLUCENT,
268 RT_PLAIN);
269 }
270 if (viBB == null) {
271 viBB = gc.createCompatibleVolatileImage(w, h, TRANSLUCENT);
272 }
273 viBB.validate(gc);
274 }
275
276 return clear ? clearImage(viBB) : viBB;
277 }
278
279 @Override
280 public void flush() {
281 if (viBB != null) {
282 viBB.flush();
283 viBB = null;
284 }
285 }
286 }
287
288 /**
289 * Optimized version of hw painter. Uses VolatileImages for the
290 * buffer, and uses an optimized path to pull the data from those into
291 * the layered window, bypassing Java heap-based image.
292 */
293 private abstract static class VIOptWindowPainter extends VIWindowPainter {
294
295 protected VIOptWindowPainter(WWindowPeer peer) {
296 super(peer);
297 }
298
299 protected abstract boolean updateWindowAccel(long psdops, int w, int h);
300
301 @Override
302 protected boolean update(Image bb) {
303 if (bb instanceof DestSurfaceProvider) {
304 Surface s = ((DestSurfaceProvider)bb).getDestSurface();
305 if (s instanceof AccelSurface) {
306 final int w = bb.getWidth(null);
307 final int h = bb.getHeight(null);
308 final boolean arr[] = { false };
309 final AccelSurface as = (AccelSurface)s;
310 RenderQueue rq = as.getContext().getRenderQueue();
311 rq.lock();
312 try {
313 as.getContext().validateContext(as);
314 rq.flushAndInvokeNow(new Runnable() {
315 public void run() {
316 long psdops = as.getNativeOps();
317 arr[0] = updateWindowAccel(psdops, w, h);
318 }
319 });
320 } catch (InvalidPipeException e) {
321 // ignore, false will be returned
322 } finally {
323 rq.unlock();
324 }
325 return arr[0];
326 }
327 }
328 return super.update(bb);
329 }
330 }
331
332 private static class VIOptD3DWindowPainter extends VIOptWindowPainter {
333
334 protected VIOptD3DWindowPainter(WWindowPeer peer) {
335 super(peer);
336 }
337
338 @Override
339 protected boolean updateWindowAccel(long psdops, int w, int h) {
340 // note: this method is executed on the toolkit thread, no sync is
341 // necessary at the native level, and a pointer to peer can be used
342 return sun.java2d.d3d.D3DSurfaceData.
343 updateWindowAccelImpl(psdops, peer.getData(), w, h);
344 }
345 }
346
347 private static class VIOptWGLWindowPainter extends VIOptWindowPainter {
348
349 protected VIOptWGLWindowPainter(WWindowPeer peer) {
350 super(peer);
351 }
352
353 @Override
354 protected boolean updateWindowAccel(long psdops, int w, int h) {
355 // note: part of this method which deals with GDI will be on the
356 // toolkit thread
357 return sun.java2d.opengl.WGLSurfaceData.
358 updateWindowAccelImpl(psdops, peer, w, h);
359 }
360 }
361 }