Attachment 367 Details for Bug 615 – X11GLXDrawableFactory version with patch for pbuffers on a second X screen.

X11GLXDrawableFactory version with patch for pbuffers on a second X screen.

X11GLXDrawableFactory.java (text/x-java), 30.98 KB, created by Rob Hatcherson on 2012-09-12 15:58:33 CEST

(hide)

Description:

Filename:

MIME Type:

Creator: Rob Hatcherson

Created: 2012-09-12 15:58:33 CEST

Size: 30.98 KB

patch

obsolete

>/*
> * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
> * Copyright (c) 2010 JogAmp Community. All rights reserved.
> *
> * Redistribution and use in source and binary forms, with or without
> * modification, are permitted provided that the following conditions are
> * met:
> *
> * - Redistribution of source code must retain the above copyright
> *   notice, this list of conditions and the following disclaimer.
> *
> * - Redistribution in binary form must reproduce the above copyright
> *   notice, this list of conditions and the following disclaimer in the
> *   documentation and/or other materials provided with the distribution.
> *
> * Neither the name of Sun Microsystems, Inc. or the names of
> * contributors may be used to endorse or promote products derived from
> * this software without specific prior written permission.
> *
> * This software is provided "AS IS," without a warranty of any kind. ALL
> * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
> * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
> * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
> * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
> * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
> * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
> * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
> * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
> * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
> * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
> * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
> *
> * You acknowledge that this software is not designed or intended for use
> * in the design, construction, operation or maintenance of any nuclear
> * facility.
> */
>
>package jogamp.opengl.x11.glx;
>
>import java.nio.Buffer;
>import java.nio.ShortBuffer;
>import java.util.Collection;
>import java.util.HashMap;
>import java.util.List;
>
>import javax.media.nativewindow.AbstractGraphicsConfiguration;
>import javax.media.nativewindow.AbstractGraphicsDevice;
>import javax.media.nativewindow.AbstractGraphicsScreen;
>import javax.media.nativewindow.NativeSurface;
>import javax.media.nativewindow.NativeWindowFactory;
>import javax.media.nativewindow.ProxySurface;
>import javax.media.nativewindow.ProxySurface.UpstreamSurfaceHook;
>import javax.media.nativewindow.VisualIDHolder;
>import javax.media.opengl.GLCapabilities;
>import javax.media.opengl.GLCapabilitiesChooser;
>import javax.media.opengl.GLCapabilitiesImmutable;
>import javax.media.opengl.GLContext;
>import javax.media.opengl.GLDrawable;
>import javax.media.opengl.GLException;
>import javax.media.opengl.GLProfile;
>import javax.media.opengl.GLProfile.ShutdownType;
>
>import jogamp.nativewindow.x11.X11Lib;
>import jogamp.nativewindow.x11.X11Util;
>import jogamp.opengl.DesktopGLDynamicLookupHelper;
>import jogamp.opengl.GLContextImpl;
>import jogamp.opengl.GLDrawableFactoryImpl;
>import jogamp.opengl.GLDrawableImpl;
>import jogamp.opengl.GLDynamicLookupHelper;
>import jogamp.opengl.GLGraphicsConfigurationUtil;
>import jogamp.opengl.SharedResourceRunner;
>
>import com.jogamp.common.util.VersionNumber;
>import com.jogamp.nativewindow.WrappedSurface;
>import com.jogamp.nativewindow.x11.X11GraphicsDevice;
>import com.jogamp.nativewindow.x11.X11GraphicsScreen;
>
>public class X11GLXDrawableFactory extends GLDrawableFactoryImpl {
>
>  public static final VersionNumber versionOneZero = new VersionNumber(1, 0, 0);
>  public static final VersionNumber versionOneOne = new VersionNumber(1, 1, 0);
>  public static final VersionNumber versionOneTwo = new VersionNumber(1, 2, 0);
>  public static final VersionNumber versionOneThree = new VersionNumber(1, 3, 0);
>  public static final VersionNumber versionOneFour = new VersionNumber(1, 4, 0);
>
>  static final String GLX_SGIX_pbuffer = "GLX_SGIX_pbuffer";
>  
>  private static DesktopGLDynamicLookupHelper x11GLXDynamicLookupHelper = null;
>
>  // Sven - the "getScreenNumberFrom" method should be evaluated further.  It works
>  // well enough, but either a) the info it parses from the connection may already
>  // be available in more convenient form elsewhere at the points where this method
>  // is called, or b) this method - geing a sort of general utility - should be
>  // located elsewhere, along with similar X11-specific utilities.
>  static int getScreenNumberFrom( String connection ) {
>    int screenNumber = 0 ;
>    // Go to the colon first since there may be a host name to the left containing dots.
>    int colonIndex = connection != null && connection.length() > 0 ? connection.indexOf( ':' ) : -1 ;
>    if( colonIndex >= 0 ) {
>      String displayAndScreen = connection.substring( colonIndex + 1 ) ;
>      int dotIndex = displayAndScreen.indexOf( '.' ) ;
>      if( dotIndex >= 0 ) {
>        try {
>          screenNumber = Integer.parseInt( displayAndScreen.substring( dotIndex + 1 ) ) ;
>        } catch( Throwable t ) {
>          // FIXME? - what should we do here?
>        }
>      }
>    }
>    return screenNumber ;
>  }
>
>  public X11GLXDrawableFactory() {
>    super();
>
>    synchronized(X11GLXDrawableFactory.class) {
>        if(null==x11GLXDynamicLookupHelper) {
>            DesktopGLDynamicLookupHelper tmp = null;
>            try {
>                tmp = new DesktopGLDynamicLookupHelper(new X11GLXDynamicLibraryBundleInfo());
>            } catch (GLException gle) {
>                if(DEBUG) {
>                    gle.printStackTrace();
>                }
>            }
>            if(null!=tmp && tmp.isLibComplete()) {
>                x11GLXDynamicLookupHelper = tmp;
>                GLX.getGLXProcAddressTable().reset(x11GLXDynamicLookupHelper);
>            }
>        }
>    }
>
>    defaultDevice = new X11GraphicsDevice(X11Util.getNullDisplayName(), AbstractGraphicsDevice.DEFAULT_UNIT);
>
>    if(null!=x11GLXDynamicLookupHelper) {
>        // Register our GraphicsConfigurationFactory implementations
>        // The act of constructing them causes them to be registered
>        X11GLXGraphicsConfigurationFactory.registerFactory();
>
>        sharedMap = new HashMap<String, SharedResourceRunner.Resource>();
>
>        // Init shared resources off thread
>        // Will be released via ShutdownHook
>        sharedResourceRunner = new SharedResourceRunner(new SharedResourceImplementation());
>        sharedResourceRunner.start();
>    }
>  }
>
>  @Override
>  protected final void destroy(ShutdownType shutdownType) {
>    if(null != sharedResourceRunner) {
>        sharedResourceRunner.stop();
>        sharedResourceRunner = null;
>    }
>    if(null != sharedMap) {
>        sharedMap.clear();
>        sharedMap = null;
>    }
>    defaultDevice = null;
>    /**
>     * Pulling away the native library may cause havoc ..
>     *
>    if(ShutdownType.COMPLETE == shutdownType && null != x11GLXDynamicLookupHelper) {
>        x11GLXDynamicLookupHelper.destroy();
>        x11GLXDynamicLookupHelper = null;
>    } */
>
>    // Don't really close pending Display connections,
>    // since this may trigger a JVM exception
>    X11Util.shutdown( false, DEBUG );
>  }
>
>  @Override
>  public final GLDynamicLookupHelper getGLDynamicLookupHelper(int profile) {
>      return x11GLXDynamicLookupHelper;
>  }
>
>  private X11GraphicsDevice defaultDevice;
>  private SharedResourceRunner sharedResourceRunner;
>  private HashMap<String /* connection */, SharedResourceRunner.Resource> sharedMap;
>
>  static class SharedResource implements SharedResourceRunner.Resource {
>      X11GraphicsDevice device;
>      X11GraphicsScreen screen;
>      GLDrawableImpl drawable;
>      GLContextImpl context;
>      String glXServerVendorName;
>      boolean isGLXServerVendorATI;
>      boolean isGLXServerVendorNVIDIA;
>      VersionNumber glXServerVersion;
>      boolean glXServerVersionOneOneCapable;
>      boolean glXServerVersionOneThreeCapable;
>      boolean glXMultisampleAvailable;
>
>      SharedResource(X11GraphicsDevice dev, X11GraphicsScreen scrn,
>                     GLDrawableImpl draw, GLContextImpl ctx,
>                     VersionNumber glXServerVer, String glXServerVendor, boolean glXServerMultisampleAvail) {
>          device = dev;
>          screen = scrn;
>          drawable = draw;
>          context = ctx;
>          glXServerVersion = glXServerVer;
>          glXServerVersionOneOneCapable = glXServerVersion.compareTo(versionOneOne) >= 0 ;
>          glXServerVersionOneThreeCapable = glXServerVersion.compareTo(versionOneThree) >= 0 ;
>          glXServerVendorName = glXServerVendor;
>          isGLXServerVendorATI = GLXUtil.isVendorATI(glXServerVendorName);
>          isGLXServerVendorNVIDIA = GLXUtil.isVendorNVIDIA(glXServerVendorName);
>          glXMultisampleAvailable = glXServerMultisampleAvail;
>      }
>      @Override
>      final public AbstractGraphicsDevice getDevice() { return device; }
>      @Override
>      final public AbstractGraphicsScreen getScreen() { return screen; }
>      @Override
>      final public GLDrawableImpl getDrawable() { return drawable; }
>      @Override
>      final public GLContextImpl getContext() { return context; }
>
>      final String getGLXVendorName() { return glXServerVendorName; }
>      final boolean isGLXVendorATI() { return isGLXServerVendorATI; }
>      final boolean isGLXVendorNVIDIA() { return isGLXServerVendorNVIDIA; }
>      final VersionNumber getGLXVersion() { return glXServerVersion; }
>      final boolean isGLXVersionGreaterEqualOneOne() { return glXServerVersionOneOneCapable; }
>      final boolean isGLXVersionGreaterEqualOneThree() { return glXServerVersionOneThreeCapable; }
>      final boolean isGLXMultisampleAvailable() { return glXMultisampleAvailable; }
>  }
>
>  class SharedResourceImplementation implements SharedResourceRunner.Implementation {
>        @Override
>        public void clear() {
>            synchronized(sharedMap) {
>                sharedMap.clear();
>            }
>        }
>        @Override
>        public SharedResourceRunner.Resource mapPut(String connection, SharedResourceRunner.Resource resource) {
>            synchronized(sharedMap) {
>                return sharedMap.put(connection, resource);
>            }
>        }
>        @Override
>        public SharedResourceRunner.Resource mapGet(String connection) {
>            synchronized(sharedMap) {
>                return sharedMap.get(connection);
>            }
>        }
>        @Override
>        public Collection<SharedResourceRunner.Resource> mapValues() {
>            synchronized(sharedMap) {
>                return sharedMap.values();
>            }
>        }
>
>        @Override
>        public SharedResourceRunner.Resource createSharedResource(String connection) {
>            final X11GraphicsDevice sharedDevice =
>                    new X11GraphicsDevice(X11Util.openDisplay(connection), AbstractGraphicsDevice.DEFAULT_UNIT,
>                                          true); // own non-shared display connection, w/ locking
>                    // new X11GraphicsDevice(X11Util.openDisplay(connection), AbstractGraphicsDevice.DEFAULT_UNIT,
>                    //                       NativeWindowFactory.getNullToolkitLock(), true); // own non-shared display connection, w/o locking
>            sharedDevice.lock();
>            try {
>                final X11GraphicsScreen sharedScreen = new X11GraphicsScreen(sharedDevice, X11GLXDrawableFactory.getScreenNumberFrom(connection) );
>                
>                if(!GLXUtil.isGLXAvailableOnServer(sharedDevice)) {
>                    throw new GLException("GLX not available on device/server: "+sharedDevice);
>                }
>                GLXUtil.initGLXClientDataSingleton(sharedDevice);
>                final String glXServerVendorName = GLX.glXQueryServerString(sharedDevice.getHandle(), 0, GLX.GLX_VENDOR);
>                final VersionNumber glXServerVersion = GLXUtil.getGLXServerVersionNumber(sharedDevice.getHandle());
>                final boolean glXServerMultisampleAvailable = GLXUtil.isMultisampleAvailable(GLX.glXQueryServerString(sharedDevice.getHandle(), 0, GLX.GLX_EXTENSIONS));
>                if(X11Util.ATI_HAS_XCLOSEDISPLAY_BUG && GLXUtil.isVendorATI(glXServerVendorName)) {
>                    X11Util.setMarkAllDisplaysUnclosable(true);
>                    X11Util.markDisplayUncloseable(sharedDevice.getHandle());
>                }
>                
>                final GLProfile glp = GLProfile.get(sharedDevice, GLProfile.GL_PROFILE_LIST_MIN_DESKTOP, false);
>                if (null == glp) {
>                    throw new GLException("Couldn't get default GLProfile for device: "+sharedDevice);
>                }
>                
>                final GLDrawableImpl sharedDrawable = createOnscreenDrawableImpl(createDummySurfaceImpl(sharedDevice, false, new GLCapabilities(glp), null, 64, 64));
>                sharedDrawable.setRealized(true);
>                
>                final GLContextImpl sharedContext = (GLContextImpl) sharedDrawable.createContext(null);
>                if (null == sharedContext) {
>                    throw new GLException("Couldn't create shared context for drawable: "+sharedDrawable);
>                }
>                
>                boolean madeCurrent = false;
>                sharedContext.makeCurrent();
>                try {
>                    madeCurrent = sharedContext.isCurrent();
>                } finally {
>                    sharedContext.release();
>                }
>                if (DEBUG) {
>                    System.err.println("SharedDevice:  " + sharedDevice);
>                    System.err.println("SharedScreen:  " + sharedScreen);
>                    System.err.println("SharedContext: " + sharedContext + ", madeCurrent " + madeCurrent);
>                    System.err.println("GLX Server Vendor:      " + glXServerVendorName);
>                    System.err.println("GLX Server Version:     " + glXServerVersion);
>                    System.err.println("GLX Server Multisample: " + glXServerMultisampleAvailable);
>                    System.err.println("GLX Client Vendor:      " + GLXUtil.getClientVendorName());
>                    System.err.println("GLX Client Version:     " + GLXUtil.getClientVersionNumber());
>                    System.err.println("GLX Client Multisample: " + GLXUtil.isClientMultisampleAvailable());
>                }
>                return new SharedResource(sharedDevice, sharedScreen, sharedDrawable, sharedContext,
>                                          glXServerVersion, glXServerVendorName,
>                                          glXServerMultisampleAvailable && GLXUtil.isClientMultisampleAvailable());
>            } catch (Throwable t) {
>                throw new GLException("X11GLXDrawableFactory - Could not initialize shared resources for "+connection, t);
>            } finally {
>                sharedDevice.unlock();
>            }
>        }
>
>        @Override
>        public void releaseSharedResource(SharedResourceRunner.Resource shared) {
>            SharedResource sr = (SharedResource) shared;
>            if (DEBUG) {
>                System.err.println("Shutdown Shared:");
>                System.err.println("Device  : " + sr.device);
>                System.err.println("Screen  : " + sr.screen);
>                System.err.println("Drawable: " + sr.drawable);
>                System.err.println("CTX     : " + sr.context);
>                Thread.dumpStack();
>            }
>
>            if (null != sr.context) {
>                // may cause JVM SIGSEGV:
>                sr.context.destroy(); // will also pull the dummy MutuableSurface
>                sr.context = null;
>            }
>
>            if (null != sr.drawable) {
>                // may cause JVM SIGSEGV:
>                sr.drawable.setRealized(false);
>                sr.drawable = null;
>            }
>
>            if (null != sr.screen) {
>                sr.screen = null;
>            }
>
>            if (null != sr.device) {
>                // may cause JVM SIGSEGV:
>                sr.device.close();
>                sr.device = null;
>            }
>        }
>  }
>
>  @Override
>  public final AbstractGraphicsDevice getDefaultDevice() {
>      return defaultDevice;
>  }
>
>  @Override
>  public final boolean getIsDeviceCompatible(AbstractGraphicsDevice device) {
>      if(null != x11GLXDynamicLookupHelper && device instanceof X11GraphicsDevice) {
>          return true;
>      }
>      return false;
>  }
>
>  @Override
>  protected final Thread getSharedResourceThread() {
>    return sharedResourceRunner.start();
>  }
>
>  @Override
>  protected final boolean createSharedResource(AbstractGraphicsDevice device) {
>    try {
>        SharedResourceRunner.Resource sr = sharedResourceRunner.getOrCreateShared(device);
>        if(null!=sr) {
>          return null != sr.getContext();
>        }
>    } catch (GLException gle) {
>        if(DEBUG) {
>            System.err.println("Catched Exception while X11GLX Shared Resource initialization");
>            gle.printStackTrace();
>        }
>    }
>    return false;
>  }
>
>  @Override
>  protected final GLContext getOrCreateSharedContextImpl(AbstractGraphicsDevice device) {
>    SharedResourceRunner.Resource sr = sharedResourceRunner.getOrCreateShared(device);
>    if(null!=sr) {
>      return sr.getContext();
>    }
>    return null;
>  }
>
>  @Override
>  protected AbstractGraphicsDevice getOrCreateSharedDeviceImpl(AbstractGraphicsDevice device) {
>    SharedResourceRunner.Resource sr = sharedResourceRunner.getOrCreateShared(device);
>    if(null!=sr) {
>        return sr.getDevice();
>    }
>    return null;
>  }
>
>  protected final long getOrCreateSharedDpy(AbstractGraphicsDevice device) {
>    SharedResourceRunner.Resource sr = sharedResourceRunner.getOrCreateShared(device);
>    if(null!=sr) {
>        return sr.getDevice().getHandle();
>    }
>    return 0;
>  }
>
>  SharedResource getOrCreateSharedResource(AbstractGraphicsDevice device) {
>    return (SharedResource) sharedResourceRunner.getOrCreateShared(device);
>  }
>
>  @Override
>  protected List<GLCapabilitiesImmutable> getAvailableCapabilitiesImpl(AbstractGraphicsDevice device) {
>    return X11GLXGraphicsConfigurationFactory.getAvailableCapabilities(this, device);
>  }
>
>  @Override
>  protected final GLDrawableImpl createOnscreenDrawableImpl(NativeSurface target) {
>    if (target == null) {
>      throw new IllegalArgumentException("Null target");
>    }
>    return new X11OnscreenGLXDrawable(this, target, false);
>  }
>
>  @Override
>  protected final GLDrawableImpl createOffscreenDrawableImpl(NativeSurface target) {
>    if (target == null) {
>      throw new IllegalArgumentException("Null target");
>    }
>    AbstractGraphicsConfiguration config = target.getGraphicsConfiguration();
>    GLCapabilitiesImmutable caps = (GLCapabilitiesImmutable) config.getChosenCapabilities();
>    if(!caps.isPBuffer()) {
>        return new X11PixmapGLXDrawable(this, target);
>    }
>
>    // PBuffer GLDrawable Creation
>    GLDrawableImpl pbufferDrawable;
>    AbstractGraphicsDevice device = config.getScreen().getDevice();
>
>    /**
>     * Due to the ATI Bug https://bugzilla.mozilla.org/show_bug.cgi?id=486277,
>     * we need to have a context current on the same Display to create a PBuffer.
>     * The dummy context shall also use the same Display,
>     * since switching Display in this regard is another ATI bug.
>     */
>    SharedResource sr = (SharedResource) sharedResourceRunner.getOrCreateShared(device);
>    if( null!=sr && sr.isGLXVendorATI() && null == GLContext.getCurrent() ) {
>        sr.getContext().makeCurrent();
>        try {
>            pbufferDrawable = new X11PbufferGLXDrawable(this, target);
>        } finally {
>            sr.getContext().release();
>        }
>    } else {
>        pbufferDrawable = new X11PbufferGLXDrawable(this, target);
>    }
>    return pbufferDrawable;
>  }
>
>  public final boolean isGLXMultisampleAvailable(AbstractGraphicsDevice device) {
>    if(null != device) {
>        SharedResource sr = (SharedResource) sharedResourceRunner.getOrCreateShared(device);
>        if(null!=sr) {
>          return sr.isGLXMultisampleAvailable();
>        }
>    }
>    return false;
>  }
>
>  public final VersionNumber getGLXVersionNumber(AbstractGraphicsDevice device) {
>    if(null != device) {
>        SharedResource sr = (SharedResource) sharedResourceRunner.getOrCreateShared(device);
>        if(null!=sr) {
>          return sr.getGLXVersion();
>        }
>        if( device instanceof X11GraphicsDevice ) {
>          return GLXUtil.getGLXServerVersionNumber(device.getHandle());
>        }
>    }
>    return null;
>  }
>
>  public final boolean isGLXVersionGreaterEqualOneOne(AbstractGraphicsDevice device) {
>    if(null != device) {
>        SharedResource sr = (SharedResource) sharedResourceRunner.getOrCreateShared(device);
>        if(null!=sr) {
>          return sr.isGLXVersionGreaterEqualOneOne();
>        }
>        if( device instanceof X11GraphicsDevice ) {
>          final VersionNumber glXServerVersion = GLXUtil.getGLXServerVersionNumber(device.getHandle());
>          return glXServerVersion.compareTo(versionOneOne) >= 0;
>        }
>    }
>    return false;
>  }
>
>  public final boolean isGLXVersionGreaterEqualOneThree(AbstractGraphicsDevice device) {
>    if(null != device) {
>        SharedResource sr = (SharedResource) sharedResourceRunner.getOrCreateShared(device);
>        if(null!=sr) {
>          return sr.isGLXVersionGreaterEqualOneThree();
>        }
>        if( device instanceof X11GraphicsDevice ) {
>          final VersionNumber glXServerVersion = GLXUtil.getGLXServerVersionNumber(device.getHandle());
>          return glXServerVersion.compareTo(versionOneThree) >= 0;
>        }
>    }
>    return false;
>  }
>
>  @Override
>  public final boolean canCreateGLPbuffer(AbstractGraphicsDevice device) {
>      if(null == device) {
>        SharedResourceRunner.Resource sr = sharedResourceRunner.getOrCreateShared(defaultDevice);
>        if(null!=sr) {
>            device = sr.getDevice();
>        }
>      }
>      return isGLXVersionGreaterEqualOneThree(device);
>  }
>
>  @Override
>  protected final ProxySurface createMutableSurfaceImpl(AbstractGraphicsDevice deviceReq, boolean createNewDevice, 
>                                                        GLCapabilitiesImmutable capsChosen,
>                                                        GLCapabilitiesImmutable capsRequested,
>                                                        GLCapabilitiesChooser chooser, int width, int height, UpstreamSurfaceHook lifecycleHook) {
>    final X11GraphicsDevice device;
>    if(createNewDevice) {
>        // Null X11 locking, due to private non-shared Display handle
>        device = new X11GraphicsDevice(X11Util.openDisplay(deviceReq.getConnection()), deviceReq.getUnitID(), NativeWindowFactory.getNullToolkitLock(), true);
>    } else {
>        device = (X11GraphicsDevice)deviceReq;
>    }
>    final X11GraphicsScreen screen = new X11GraphicsScreen(device, getScreenNumberFrom( device.getConnection() ) );
>    final X11GLXGraphicsConfiguration config = X11GLXGraphicsConfigurationFactory.chooseGraphicsConfigurationStatic(capsChosen, capsRequested, chooser, screen, VisualIDHolder.VID_UNDEFINED);
>    if(null == config) {
>        throw new GLException("Choosing GraphicsConfiguration failed w/ "+capsChosen+" on "+screen); 
>    }
>    return new WrappedSurface( config, 0, width, height, lifecycleHook);
>  }
>
>  @Override
>  public final ProxySurface createDummySurfaceImpl(AbstractGraphicsDevice deviceReq, boolean createNewDevice, 
>                                                   GLCapabilitiesImmutable requestedCaps, GLCapabilitiesChooser chooser, int width, int height) {
>    final GLCapabilitiesImmutable chosenCaps = GLGraphicsConfigurationUtil.fixOnscreenGLCapabilities(requestedCaps);
>    return createMutableSurfaceImpl(deviceReq, createNewDevice, chosenCaps, requestedCaps, chooser, width, height, dummySurfaceLifecycleHook); 
>  }  
>  private static final ProxySurface.UpstreamSurfaceHook dummySurfaceLifecycleHook = new ProxySurface.UpstreamSurfaceHook() {
>    @Override
>    public final void create(ProxySurface s) {
>        if( 0 == s.getSurfaceHandle() ) {
>            final X11GLXGraphicsConfiguration cfg = (X11GLXGraphicsConfiguration) s.getGraphicsConfiguration();
>            final X11GraphicsScreen screen = (X11GraphicsScreen) cfg.getScreen();
>            final X11GraphicsDevice device = (X11GraphicsDevice) screen.getDevice();
>            if(0 == device.getHandle()) {
>                device.open();
>                s.setImplBitfield(ProxySurface.OWN_DEVICE);
>            }
>            final long windowHandle = X11Lib.CreateDummyWindow(device.getHandle(), screen.getIndex(), cfg.getXVisualID(), s.getWidth(), s.getHeight());
>            if(0 == windowHandle) {
>                throw new GLException("Creating dummy window failed w/ "+cfg+", "+s.getWidth()+"x"+s.getHeight());
>            }
>            s.setSurfaceHandle(windowHandle);
>            if(DEBUG) {
>                System.err.println("X11GLXDrawableFactory.dummySurfaceLifecycleHook.create: "+s);
>            }
>        }
>    }
>    @Override
>    public final void destroy(ProxySurface s) {
>        if(0 != s.getSurfaceHandle()) {
>            final X11GLXGraphicsConfiguration config = (X11GLXGraphicsConfiguration) s.getGraphicsConfiguration();
>            final X11GraphicsDevice device = (X11GraphicsDevice) config.getScreen().getDevice();
>            X11Lib.DestroyDummyWindow(device.getHandle(), s.getSurfaceHandle());            
>            s.setSurfaceHandle(0);
>            if( 0 != ( ProxySurface.OWN_DEVICE & s.getImplBitfield() ) ) {
>                device.close();
>            }
>            if(DEBUG) {
>                System.err.println("X11GLXDrawableFactory.dummySurfaceLifecycleHook.destroy: "+s);
>            }
>        }
>    }
>    @Override
>    public final int getWidth(ProxySurface s) {
>        return s.initialWidth;
>    }
>    @Override
>    public final int getHeight(ProxySurface s) {
>        return s.initialHeight;
>    }
>    @Override
>    public String toString() {
>       return "X11SurfaceLifecycleHook[]";
>    }
>  };
>  
>  
>  @Override
>  protected final ProxySurface createProxySurfaceImpl(AbstractGraphicsDevice deviceReq, int screenIdx, long windowHandle, GLCapabilitiesImmutable capsRequested, GLCapabilitiesChooser chooser, UpstreamSurfaceHook upstream) {
>    final X11GraphicsDevice device = new X11GraphicsDevice(X11Util.openDisplay(deviceReq.getConnection()), deviceReq.getUnitID(), NativeWindowFactory.getNullToolkitLock(), true);
>    final X11GraphicsScreen screen = new X11GraphicsScreen(device, screenIdx);
>    final int xvisualID = X11Lib.GetVisualIDFromWindow(device.getHandle(), windowHandle);
>    if(VisualIDHolder.VID_UNDEFINED == xvisualID) {
>        throw new GLException("Undefined VisualID of window 0x"+Long.toHexString(windowHandle)+", window probably invalid");
>    }
>    if(DEBUG) {
>        System.err.println("X11GLXDrawableFactory.createProxySurfaceImpl 0x"+Long.toHexString(windowHandle)+": visualID 0x"+Integer.toHexString(xvisualID));
>    }
>    final X11GLXGraphicsConfiguration cfg = X11GLXGraphicsConfigurationFactory.chooseGraphicsConfigurationStatic(capsRequested, capsRequested, chooser, screen, xvisualID);
>    if(DEBUG) {
>        System.err.println("X11GLXDrawableFactory.createProxySurfaceImpl 0x"+Long.toHexString(windowHandle)+": "+cfg);
>    }
>    return new WrappedSurface(cfg, windowHandle, 0, 0, upstream);
>  }
>
>  @Override
>  protected final GLContext createExternalGLContextImpl() {
>    return X11ExternalGLXContext.create(this, null);
>  }
>
>  @Override
>  public final boolean canCreateExternalGLDrawable(AbstractGraphicsDevice device) {
>    return canCreateGLPbuffer(device);
>  }
>
>  @Override
>  protected final GLDrawable createExternalGLDrawableImpl() {
>    return X11ExternalGLXDrawable.create(this, null);
>  }
>
>  @Override
>  public final boolean canCreateContextOnJava2DSurface(AbstractGraphicsDevice device) {
>    return false;
>  }
>
>  @Override
>  public final GLContext createContextOnJava2DSurface(Object graphics, GLContext shareWith)
>    throws GLException {
>    throw new GLException("Unimplemented on this platform");
>  }
>
>  //----------------------------------------------------------------------
>  // Gamma-related functionality
>  //
>
>  private boolean gotGammaRampLength;
>  private int gammaRampLength;
>  @Override
>  protected final synchronized int getGammaRampLength() {
>    if (gotGammaRampLength) {
>      return gammaRampLength;
>    }
>
>    long display = getOrCreateSharedDpy(defaultDevice);
>    if(0 == display) {
>        return 0;
>    }
>
>    int[] size = new int[1];
>    boolean res = X11Lib.XF86VidModeGetGammaRampSize(display,
>                                                      X11Lib.DefaultScreen(display),
>                                                      size, 0);
>    if (!res) {
>      return 0;
>    }
>    gotGammaRampLength = true;
>    gammaRampLength = size[0];
>    return gammaRampLength;
>  }
>
>  @Override
>  protected final boolean setGammaRamp(float[] ramp) {
>    long display = getOrCreateSharedDpy(defaultDevice);
>    if(0 == display) {
>        return false;
>    }
>
>    int len = ramp.length;
>    short[] rampData = new short[len];
>    for (int i = 0; i < len; i++) {
>      rampData[i] = (short) (ramp[i] * 65535);
>    }
>
>    boolean res = X11Lib.XF86VidModeSetGammaRamp(display,
>                                              X11Lib.DefaultScreen(display),
>                                              rampData.length,
>                                              rampData, 0,
>                                              rampData, 0,
>                                              rampData, 0);
>    return res;
>  }
>
>  @Override
>  protected final Buffer getGammaRamp() {
>    long display = getOrCreateSharedDpy(defaultDevice);
>    if(0 == display) {
>        return null;
>    }
>
>    int size = getGammaRampLength();
>    ShortBuffer rampData = ShortBuffer.wrap(new short[3 * size]);
>    rampData.position(0);
>    rampData.limit(size);
>    ShortBuffer redRampData = rampData.slice();
>    rampData.position(size);
>    rampData.limit(2 * size);
>    ShortBuffer greenRampData = rampData.slice();
>    rampData.position(2 * size);
>    rampData.limit(3 * size);
>    ShortBuffer blueRampData = rampData.slice();
>
>    boolean res = X11Lib.XF86VidModeGetGammaRamp(display,
>                                              X11Lib.DefaultScreen(display),
>                                              size,
>                                              redRampData,
>                                              greenRampData,
>                                              blueRampData);
>    if (!res) {
>      return null;
>    }
>    return rampData;
>  }
>
>  @Override
>  protected final void resetGammaRamp(Buffer originalGammaRamp) {
>    if (originalGammaRamp == null) {
>        return; // getGammaRamp failed originally
>    }
>    long display = getOrCreateSharedDpy(defaultDevice);
>    if(0 == display) {
>        return;
>    }
>
>    ShortBuffer rampData = (ShortBuffer) originalGammaRamp;
>    int capacity = rampData.capacity();
>    if ((capacity % 3) != 0) {
>      throw new IllegalArgumentException("Must not be the original gamma ramp");
>    }
>    int size = capacity / 3;
>    rampData.position(0);
>    rampData.limit(size);
>    ShortBuffer redRampData = rampData.slice();
>    rampData.position(size);
>    rampData.limit(2 * size);
>    ShortBuffer greenRampData = rampData.slice();
>    rampData.position(2 * size);
>    rampData.limit(3 * size);
>    ShortBuffer blueRampData = rampData.slice();
>
>    X11Lib.XF86VidModeSetGammaRamp(display,
>                                X11Lib.DefaultScreen(display),
>                                size,
>                                redRampData,
>                                greenRampData,
>                                blueRampData);
>  }
>}

Actions: View

Attachments on bug 615: 367