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.java2d.opengl; 27 28 import java.awt.AWTException; 29 import java.awt.BufferCapabilities; 30 import java.awt.Color; 31 import java.awt.Component; 32 import java.awt.Graphics; 33 import java.awt.Graphics2D; 34 import java.awt.Image; 35 import java.awt.ImageCapabilities; 36 import java.awt.Transparency; 37 import java.awt.color.ColorSpace; 38 import java.awt.image.BufferedImage; 39 import java.awt.image.ColorModel; 40 import java.awt.image.DataBuffer; 41 import java.awt.image.DirectColorModel; 42 import java.awt.image.VolatileImage; 43 import java.awt.image.WritableRaster; 44 import sun.awt.X11ComponentPeer; 45 import sun.awt.X11GraphicsConfig; 46 import sun.awt.X11GraphicsDevice; 47 import sun.awt.X11GraphicsEnvironment; 48 import sun.awt.image.OffScreenImage; 49 import sun.awt.image.SunVolatileImage; 50 import sun.awt.image.SurfaceManager; 51 import sun.java2d.SunGraphics2D; 52 import sun.java2d.Surface; 53 import sun.java2d.SurfaceData; 54 import sun.java2d.pipe.hw.AccelSurface; 55 import sun.java2d.pipe.hw.AccelTypedVolatileImage; 56 import sun.java2d.pipe.hw.ContextCapabilities; 57 import static sun.java2d.opengl.OGLSurfaceData.*; 58 import static sun.java2d.opengl.OGLContext.*; 59 import static sun.java2d.opengl.OGLContext.OGLContextCaps.*; 60 import sun.java2d.opengl.GLXSurfaceData.GLXVSyncOffScreenSurfaceData; 61 62 public class GLXGraphicsConfig 63 extends X11GraphicsConfig 64 implements OGLGraphicsConfig 65 { 66 private static ImageCapabilities imageCaps = new GLXImageCaps(); 67 private BufferCapabilities bufferCaps; 68 private long pConfigInfo; 69 private ContextCapabilities oglCaps; 70 private OGLContext context; 71 72 private static native long getGLXConfigInfo(int screennum, int visualnum); 73 private static native int getOGLCapabilities(long configInfo); 74 private native void initConfig(long aData, long ctxinfo); 75 76 private GLXGraphicsConfig(X11GraphicsDevice device, int visualnum, 77 long configInfo, ContextCapabilities oglCaps) 78 { 79 super(device, visualnum, 0, 0, 80 (oglCaps.getCaps() & CAPS_DOUBLEBUFFERED) != 0); 81 pConfigInfo = configInfo; 82 initConfig(getAData(), configInfo); 83 this.oglCaps = oglCaps; 84 context = new OGLContext(OGLRenderQueue.getInstance(), this); 85 } 86 87 @Override 88 public Object getProxyKey() { 89 return this; 90 } 91 92 @Override 93 public SurfaceData createManagedSurface(int w, int h, int transparency) { 94 return GLXSurfaceData.createData(this, w, h, 95 getColorModel(transparency), 96 null, 97 OGLSurfaceData.TEXTURE); 98 } 99 100 public static GLXGraphicsConfig getConfig(X11GraphicsDevice device, 101 int visualnum) 102 { 103 if (!X11GraphicsEnvironment.isGLXAvailable()) { 104 return null; 105 } 106 107 long cfginfo = 0; 108 final String ids[] = new String[1]; 109 OGLRenderQueue rq = OGLRenderQueue.getInstance(); 110 rq.lock(); 111 try { 112 // getGLXConfigInfo() creates and destroys temporary 113 // surfaces/contexts, so we should first invalidate the current 114 // Java-level context and flush the queue... 115 OGLContext.invalidateCurrentContext(); 116 GLXGetConfigInfo action = 117 new GLXGetConfigInfo(device.getScreen(), visualnum); 118 rq.flushAndInvokeNow(action); 119 cfginfo = action.getConfigInfo(); 120 if (cfginfo != 0L) { 121 OGLContext.setScratchSurface(cfginfo); 122 rq.flushAndInvokeNow(new Runnable() { 123 public void run() { 124 ids[0] = OGLContext.getOGLIdString(); 125 } 126 }); 127 } 128 } finally { 129 rq.unlock(); 130 } 131 if (cfginfo == 0) { 132 return null; 133 } 134 135 int oglCaps = getOGLCapabilities(cfginfo); 136 ContextCapabilities caps = new OGLContextCaps(oglCaps, ids[0]); 137 138 return new GLXGraphicsConfig(device, visualnum, cfginfo, caps); 139 } 140 141 /** 142 * This is a small helper class that allows us to execute 143 * getGLXConfigInfo() on the queue flushing thread. 144 */ 145 private static class GLXGetConfigInfo implements Runnable { 146 private int screen; 147 private int visual; 148 private long cfginfo; 149 private GLXGetConfigInfo(int screen, int visual) { 150 this.screen = screen; 151 this.visual = visual; 152 } 153 public void run() { 154 cfginfo = getGLXConfigInfo(screen, visual); 155 } 156 public long getConfigInfo() { 157 return cfginfo; 158 } 159 } 160 161 /** 162 * Returns true if the provided capability bit is present for this config. 163 * See OGLContext.java for a list of supported capabilities. 164 */ 165 @Override 166 public final boolean isCapPresent(int cap) { 167 return ((oglCaps.getCaps() & cap) != 0); 168 } 169 170 @Override 171 public final long getNativeConfigInfo() { 172 return pConfigInfo; 173 } 174 175 /** 176 * {@inheritDoc} 177 * 178 * @see sun.java2d.pipe.hw.BufferedContextProvider#getContext 179 */ 180 @Override 181 public final OGLContext getContext() { 182 return context; 183 } 184 185 @Override 186 public BufferedImage createCompatibleImage(int width, int height) { 187 ColorModel model = new DirectColorModel(24, 0xff0000, 0xff00, 0xff); 188 WritableRaster 189 raster = model.createCompatibleWritableRaster(width, height); 190 return new BufferedImage(model, raster, model.isAlphaPremultiplied(), 191 null); 192 } 193 194 @Override 195 public ColorModel getColorModel(int transparency) { 196 switch (transparency) { 197 case Transparency.OPAQUE: 198 // REMIND: once the ColorModel spec is changed, this should be 199 // an opaque premultiplied DCM... 200 return new DirectColorModel(24, 0xff0000, 0xff00, 0xff); 201 case Transparency.BITMASK: 202 return new DirectColorModel(25, 0xff0000, 0xff00, 0xff, 0x1000000); 203 case Transparency.TRANSLUCENT: 204 ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_sRGB); 205 return new DirectColorModel(cs, 32, 206 0xff0000, 0xff00, 0xff, 0xff000000, 207 true, DataBuffer.TYPE_INT); 208 default: 209 return null; 210 } 211 } 212 213 public String toString() { 214 return ("GLXGraphicsConfig[dev="+screen+ 215 ",vis=0x"+Integer.toHexString(visual)+ 216 "]"); 217 } 218 219 /** 220 * The following methods are invoked from MToolkit or XToolkit.java and 221 * X11ComponentPeer.java rather than having the X11-dependent 222 * implementations hardcoded in those classes. This way the appropriate 223 * actions are taken based on the peer's GraphicsConfig, whether it is 224 * an X11GraphicsConfig or a GLXGraphicsConfig. 225 */ 226 227 /** 228 * Creates a new SurfaceData that will be associated with the given 229 * X11ComponentPeer. 230 */ 231 @Override 232 public SurfaceData createSurfaceData(X11ComponentPeer peer) { 233 return GLXSurfaceData.createData(peer); 234 } 235 236 /** 237 * Creates a new hidden-acceleration image of the given width and height 238 * that is associated with the target Component. 239 */ 240 @Override 241 public Image createAcceleratedImage(Component target, 242 int width, int height) 243 { 244 ColorModel model = getColorModel(Transparency.OPAQUE); 245 WritableRaster wr = 246 model.createCompatibleWritableRaster(width, height); 247 return new OffScreenImage(target, model, wr, 248 model.isAlphaPremultiplied()); 249 } 250 251 /** 252 * The following methods correspond to the multibuffering methods in 253 * X11ComponentPeer.java... 254 */ 255 256 /** 257 * Attempts to create a GLX-based backbuffer for the given peer. If 258 * the requested configuration is not natively supported, an AWTException 259 * is thrown. Otherwise, if the backbuffer creation is successful, a 260 * value of 1 is returned. 261 */ 262 @Override 263 public long createBackBuffer(X11ComponentPeer peer, 264 int numBuffers, BufferCapabilities caps) 265 throws AWTException 266 { 267 if (numBuffers > 2) { 268 throw new AWTException( 269 "Only double or single buffering is supported"); 270 } 271 BufferCapabilities configCaps = getBufferCapabilities(); 272 if (!configCaps.isPageFlipping()) { 273 throw new AWTException("Page flipping is not supported"); 274 } 275 if (caps.getFlipContents() == BufferCapabilities.FlipContents.PRIOR) { 276 throw new AWTException("FlipContents.PRIOR is not supported"); 277 } 278 279 // non-zero return value means backbuffer creation was successful 280 // (checked in X11ComponentPeer.flip(), etc.) 281 return 1; 282 } 283 284 /** 285 * Destroys the backbuffer object represented by the given handle value. 286 */ 287 @Override 288 public void destroyBackBuffer(long backBuffer) { 289 } 290 291 /** 292 * Creates a VolatileImage that essentially wraps the target Component's 293 * backbuffer (the provided backbuffer handle is essentially ignored). 294 */ 295 @Override 296 public VolatileImage createBackBufferImage(Component target, 297 long backBuffer) 298 { 299 return new SunVolatileImage(target, 300 target.getWidth(), target.getHeight(), 301 Boolean.TRUE); 302 } 303 304 /** 305 * Performs the native GLX flip operation for the given target Component. 306 */ 307 @Override 308 public void flip(X11ComponentPeer peer, 309 Component target, VolatileImage xBackBuffer, 310 int x1, int y1, int x2, int y2, 311 BufferCapabilities.FlipContents flipAction) 312 { 313 if (flipAction == BufferCapabilities.FlipContents.COPIED) { 314 SurfaceManager vsm = SurfaceManager.getManager(xBackBuffer); 315 SurfaceData sd = vsm.getPrimarySurfaceData(); 316 317 if (sd instanceof GLXVSyncOffScreenSurfaceData) { 318 GLXVSyncOffScreenSurfaceData vsd = 319 (GLXVSyncOffScreenSurfaceData)sd; 320 SurfaceData bbsd = vsd.getFlipSurface(); 321 Graphics2D bbg = 322 new SunGraphics2D(bbsd, Color.black, Color.white, null); 323 try { 324 bbg.drawImage(xBackBuffer, 0, 0, null); 325 } finally { 326 bbg.dispose(); 327 } 328 } else { 329 Graphics g = peer.getGraphics(); 330 try { 331 g.drawImage(xBackBuffer, 332 x1, y1, x2, y2, 333 x1, y1, x2, y2, 334 null); 335 } finally { 336 g.dispose(); 337 } 338 return; 339 } 340 } else if (flipAction == BufferCapabilities.FlipContents.PRIOR) { 341 // not supported by GLX... 342 return; 343 } 344 345 OGLSurfaceData.swapBuffers(peer.getContentWindow()); 346 347 if (flipAction == BufferCapabilities.FlipContents.BACKGROUND) { 348 Graphics g = xBackBuffer.getGraphics(); 349 try { 350 g.setColor(target.getBackground()); 351 g.fillRect(0, 0, 352 xBackBuffer.getWidth(), 353 xBackBuffer.getHeight()); 354 } finally { 355 g.dispose(); 356 } 357 } 358 } 359 360 private static class GLXBufferCaps extends BufferCapabilities { 361 public GLXBufferCaps(boolean dblBuf) { 362 super(imageCaps, imageCaps, 363 dblBuf ? FlipContents.UNDEFINED : null); 364 } 365 } 366 367 @Override 368 public BufferCapabilities getBufferCapabilities() { 369 if (bufferCaps == null) { 370 bufferCaps = new GLXBufferCaps(isDoubleBuffered()); 371 } 372 return bufferCaps; 373 } 374 375 private static class GLXImageCaps extends ImageCapabilities { 376 private GLXImageCaps() { 377 super(true); 378 } 379 public boolean isTrueVolatile() { 380 return true; 381 } 382 } 383 384 @Override 385 public ImageCapabilities getImageCapabilities() { 386 return imageCaps; 387 } 388 389 /** 390 * {@inheritDoc} 391 * 392 * @see sun.java2d.pipe.hw.AccelGraphicsConfig#createCompatibleVolatileImage 393 */ 394 @Override 395 public VolatileImage 396 createCompatibleVolatileImage(int width, int height, 397 int transparency, int type) 398 { 399 if ((type != FBOBJECT && type != TEXTURE) 400 || transparency == Transparency.BITMASK 401 || type == FBOBJECT && !isCapPresent(CAPS_EXT_FBOBJECT)) { 402 return null; 403 } 404 SunVolatileImage vi = new AccelTypedVolatileImage(this, width, height, 405 transparency, type); 406 Surface sd = vi.getDestSurface(); 407 if (!(sd instanceof AccelSurface) || 408 ((AccelSurface)sd).getType() != type) 409 { 410 vi.flush(); 411 vi = null; 412 } 413 414 return vi; 415 } 416 417 /** 418 * {@inheritDoc} 419 * 420 * @see sun.java2d.pipe.hw.AccelGraphicsConfig#getContextCapabilities 421 */ 422 @Override 423 public ContextCapabilities getContextCapabilities() { 424 return oglCaps; 425 } 426 }