1 /*
2 * Copyright (c) 2003, 2015, 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.awt.image;
27
28 import java.awt.Graphics;
29 import java.awt.GraphicsConfiguration;
30 import java.awt.GraphicsEnvironment;
31 import java.awt.ImageCapabilities;
32 import java.awt.geom.AffineTransform;
33 import java.awt.image.BufferedImage;
34 import java.awt.image.VolatileImage;
35 import sun.awt.DisplayChangedListener;
36 import sun.java2d.SunGraphicsEnvironment;
37 import sun.java2d.SurfaceData;
38 import static sun.java2d.pipe.hw.AccelSurface.*;
39
40 /**
41 * This SurfaceManager variant manages an accelerated volatile surface, if it
42 * is possible to create that surface. If there is limited accelerated
43 * memory, or if the volatile surface disappears due to an operating system
44 * event, the VolatileSurfaceManager will attempt to restore the
45 * accelerated surface. If that fails, a system memory surface will be
46 * created in its place.
47 */
48 public abstract class VolatileSurfaceManager
49 extends SurfaceManager
50 implements DisplayChangedListener
51 {
52 /**
53 * A reference to the VolatileImage whose contents are being managed.
54 */
55 protected SunVolatileImage vImg;
56
57 /**
58 * The accelerated SurfaceData object.
59 */
60 protected SurfaceData sdAccel;
61
62 /**
63 * The software-based SurfaceData object. Only create when first asked
64 * to (otherwise it is a waste of memory as it will only be used in
65 * situations of surface loss).
66 */
67 protected SurfaceData sdBackup;
68
69 /**
70 * The current SurfaceData object.
71 */
72 protected SurfaceData sdCurrent;
73
74 /**
75 * A record-keeping object. This keeps track of which SurfaceData was
76 * in use during the last call to validate(). This lets us see whether
77 * the SurfaceData object has changed since then and allows us to return
78 * the correct returnCode to the user in the validate() call.
79 */
80 protected SurfaceData sdPrevious;
81
82 /**
83 * Tracks loss of surface contents; queriable by user to see whether
84 * contents need to be restored.
85 */
86 protected boolean lostSurface;
87
88 /**
89 * Context for extra initialization parameters.
90 */
91 protected Object context;
92
93 protected VolatileSurfaceManager(SunVolatileImage vImg, Object context) {
94 this.vImg = vImg;
95 this.context = context;
96
97 GraphicsEnvironment ge =
98 GraphicsEnvironment.getLocalGraphicsEnvironment();
99 // We could have a HeadlessGE at this point, so double-check before
100 // assuming anything.
101 if (ge instanceof SunGraphicsEnvironment) {
102 ((SunGraphicsEnvironment)ge).addDisplayChangedListener(this);
103 }
104 }
105
106 /**
107 * This init function is separate from the constructor because the
108 * things we are doing here necessitate the object's existence.
109 * Otherwise, we end up calling into a subclass' overridden method
110 * during construction, before that subclass is completely constructed.
111 */
112 public void initialize() {
113 if (isAccelerationEnabled()) {
114 sdAccel = initAcceleratedSurface();
115 if (sdAccel != null) {
116 sdCurrent = sdAccel;
117 }
118 }
119 // only initialize the backup surface for images with unforced
120 // acceleration type
121 if (sdCurrent == null &&
122 vImg.getForcedAccelSurfaceType() == UNDEFINED)
123 {
124 sdCurrent = getBackupSurface();
125 }
126 }
127
128 public SurfaceData getPrimarySurfaceData() {
129 return sdCurrent;
130 }
131
132 /**
133 * Returns true if acceleration is enabled. If not, we simply use the
134 * backup SurfaceData object and return quickly from most methods
135 * in this class.
136 */
137 protected abstract boolean isAccelerationEnabled();
138
139 /**
140 * Get the image ready for rendering. This method is called to make
141 * sure that the accelerated SurfaceData exists and is
142 * ready to be used. Users call this method prior to any set of
143 * rendering to or from the image, to make sure the image is ready
144 * and compatible with the given GraphicsConfiguration.
145 *
146 * The image may not be "ready" if either we had problems creating
147 * it in the first place (e.g., there was no space in vram) or if
148 * the surface became lost (e.g., some other app or the OS caused
149 * vram surfaces to be removed).
150 *
151 * Note that we want to return RESTORED in any situation where the
152 * SurfaceData is different than it was last time. So whether it's
153 * software or hardware, if we have a different SurfaceData object,
154 * then the contents have been altered and we must reflect that
155 * change to the user.
156 */
157 public int validate(GraphicsConfiguration gc) {
158 int returnCode = VolatileImage.IMAGE_OK;
159 boolean lostSurfaceTmp = lostSurface;
160 lostSurface = false;
161
162 if (isAccelerationEnabled()) {
163 if (!isConfigValid(gc)) {
164 // If we're asked to render to a different device than the
165 // one we were created under, return INCOMPATIBLE error code.
166 // Note that a null gc simply ignores the incompatibility
167 // issue
168 returnCode = VolatileImage.IMAGE_INCOMPATIBLE;
169 } else if (sdAccel == null) {
170 // We either had problems creating the surface or the display
171 // mode changed and we nullified the old one. Try it again.
172 sdAccel = initAcceleratedSurface();
173 if (sdAccel != null) {
174 // set the current SurfaceData to accelerated version
175 sdCurrent = sdAccel;
176 // we don't need the system memory surface anymore, so
177 // let's release it now (it can always be restored later)
178 sdBackup = null;
179 returnCode = VolatileImage.IMAGE_RESTORED;
180 } else {
181 sdCurrent = getBackupSurface();
182 }
183 } else if (sdAccel.isSurfaceLost()) {
184 try {
185 restoreAcceleratedSurface();
186 // set the current SurfaceData to accelerated version
187 sdCurrent = sdAccel;
188 // restoration successful: accel surface no longer lost
189 sdAccel.setSurfaceLost(false);
190 // we don't need the system memory surface anymore, so
191 // let's release it now (it can always be restored later)
192 sdBackup = null;
193 returnCode = VolatileImage.IMAGE_RESTORED;
194 } catch (sun.java2d.InvalidPipeException e) {
195 // Set the current SurfaceData to software version so that
196 // drawing can continue. Note that we still have
197 // the lostAccelSurface flag set so that we will continue
198 // to attempt to restore the accelerated surface.
199 sdCurrent = getBackupSurface();
200 }
201 } else if (lostSurfaceTmp) {
202 // Something else triggered this loss/restoration. Could
203 // be a palette change that didn't require a SurfaceData
204 // recreation but merely a re-rendering of the pixels.
205 returnCode = VolatileImage.IMAGE_RESTORED;
206 }
207 } else if (sdAccel != null) {
208 // if the "acceleration enabled" state changed to disabled,
209 // switch to software surface
210 sdCurrent = getBackupSurface();
211 sdAccel = null;
212 returnCode = VolatileImage.IMAGE_RESTORED;
213 }
214
215 if ((returnCode != VolatileImage.IMAGE_INCOMPATIBLE) &&
216 (sdCurrent != sdPrevious))
217 {
218 // contents have changed - return RESTORED to user
219 sdPrevious = sdCurrent;
220 returnCode = VolatileImage.IMAGE_RESTORED;
221 }
222
223 if (returnCode == VolatileImage.IMAGE_RESTORED) {
224 // clear the current surface with the background color,
225 // only if the surface has been restored
226 initContents();
227 }
228
229 return returnCode;
230 }
231
232 /**
233 * Returns true if rendering data was lost since the last validate call.
234 *
235 * @see java.awt.image.VolatileImage#contentsLost
236 */
237 public boolean contentsLost() {
238 return lostSurface;
239 }
240
241 /**
242 * Creates a new accelerated surface that is compatible with the
243 * current GraphicsConfiguration. Returns the new accelerated
244 * SurfaceData object, or null if the surface creation was not successful.
245 *
246 * Platform-specific subclasses should initialize an accelerated
247 * surface (e.g. a DirectDraw surface on Windows, an OpenGL FBO,
248 * or an X11 pixmap).
249 */
250 protected abstract SurfaceData initAcceleratedSurface();
251
252 /**
253 * Creates a software-based surface (of type BufImgSurfaceData).
254 * The software representation is only created when needed, which
255 * is only during some situation in which the hardware surface
256 * cannot be allocated. This allows apps to at least run,
257 * albeit more slowly than they would otherwise.
258 */
259 protected SurfaceData getBackupSurface() {
260 if (sdBackup == null) {
261 GraphicsConfiguration gc = vImg.getGraphicsConfig();
262 AffineTransform tx = gc.getDefaultTransform();
263 double scaleX = tx.getScaleX();
264 double scaleY = tx.getScaleY();
265 BufferedImage bImg = vImg.getBackupImage(scaleX, scaleY);
266 // Sabotage the acceleration capabilities of the BufImg surface
267 SunWritableRaster.stealTrackable(bImg
268 .getRaster()
269 .getDataBuffer()).setUntrackable();
270 sdBackup = BufImgSurfaceData.createData(bImg, scaleX, scaleY);
271 }
272 return sdBackup;
273 }
274
275 /**
276 * Set contents of the current SurfaceData to default state (i.e. clear
277 * the background).
278 */
279 public void initContents() {
280 // images with forced acceleration type may have a null sdCurrent
281 // because we do not create a backup surface for them
282 if (sdCurrent != null) {
283 Graphics g = vImg.createGraphics();
284 g.clearRect(0, 0, vImg.getWidth(), vImg.getHeight());
285 g.dispose();
286 }
287 }
288
289 /**
290 * Called from a SurfaceData object, indicating that our
291 * accelerated surface has been lost and should be restored (perhaps
292 * using a backup system memory surface). Returns the newly restored
293 * primary SurfaceData object.
294 */
295 public SurfaceData restoreContents() {
296 return getBackupSurface();
297 }
298
299 /**
300 * If the accelerated surface is the current SurfaceData for this manager,
301 * sets the variable lostSurface to true, which indicates that something
302 * happened to the image under management. This variable is used in the
303 * validate method to tell the caller that the surface contents need to
304 * be restored.
305 */
306 public void acceleratedSurfaceLost() {
307 if (isAccelerationEnabled() && (sdCurrent == sdAccel)) {
308 lostSurface = true;
309 }
310 }
311
312 /**
313 * Restore sdAccel in case it was lost. Do nothing in this
314 * default case; platform-specific implementations may do more in
315 * this situation as appropriate.
316 */
317 protected void restoreAcceleratedSurface() {
318 }
319
320 /**
321 * Called from SunGraphicsEnv when there has been a display mode change.
322 * Note that we simply invalidate hardware surfaces here; we do not
323 * attempt to recreate or re-render them. This is to avoid threading
324 * conflicts with the native toolkit and associated threads. Instead,
325 * we just nullify the old surface data object and wait for a future
326 * method in the rendering process to recreate the surface.
327 */
328 public void displayChanged() {
329 if (!isAccelerationEnabled()) {
330 return;
331 }
332 lostSurface = true;
333 if (sdAccel != null) {
334 // First, nullify the software surface. This guards against
335 // using a SurfaceData that was created in a different
336 // display mode.
337 sdBackup = null;
338 // Now, invalidate the old hardware-based SurfaceData
339 // Note that getBackupSurface may set sdAccel to null so we have to invalidate it before
340 SurfaceData oldData = sdAccel;
341 sdAccel = null;
342 oldData.invalidate();
343 sdCurrent = getBackupSurface();
344 }
345 // Update graphicsConfig for the vImg in case it changed due to
346 // this display change event
347 vImg.updateGraphicsConfig();
348 }
349
350 /**
351 * When device palette changes, need to force a new copy
352 * of the image into our hardware cache to update the
353 * color indices of the pixels (indexed mode only).
354 */
355 public void paletteChanged() {
356 lostSurface = true;
357 }
358
359 /**
360 * Called by validate() to see whether the GC passed in is ok for
361 * rendering to. This generic implementation checks to see
362 * whether the GC is either null or is from the same
363 * device as the one that this image was created on. Platform-
364 * specific implementations may perform other checks as
365 * appropriate.
366 */
367 protected boolean isConfigValid(GraphicsConfiguration gc) {
368 return ((gc == null) ||
369 (gc.getDevice() == vImg.getGraphicsConfig().getDevice()));
370 }
371
372 @Override
373 public ImageCapabilities getCapabilities(GraphicsConfiguration gc) {
374 if (isConfigValid(gc)) {
375 return isAccelerationEnabled() ?
376 new AcceleratedImageCapabilities() :
377 new ImageCapabilities(false);
378 }
379 return super.getCapabilities(gc);
380 }
381
382 private class AcceleratedImageCapabilities
383 extends ImageCapabilities
384 {
385 AcceleratedImageCapabilities() {
386 super(false);
387 }
388 @Override
389 public boolean isAccelerated() {
390 return (sdCurrent == sdAccel);
391 }
392 @Override
393 public boolean isTrueVolatile() {
394 return isAccelerated();
395 }
396 }
397
398 /**
399 * Releases any associated hardware memory for this image by
400 * calling flush on sdAccel. This method forces a lostSurface
401 * situation so any future operations on the image will need to
402 * revalidate the image first.
403 */
404 public void flush() {
405 lostSurface = true;
406 SurfaceData oldSD = sdAccel;
407 sdAccel = null;
408 if (oldSD != null) {
409 oldSD.flush();
410 }
411 }
412 }