private static List<GLCapabilitiesImmutable> getAvailableEGLConfigs(
EGLGraphicsDevice eglDisplay, GLCapabilitiesImmutable caps) {
final IntBuffer numConfigs = Buffers.newDirectIntBuffer(1);
if (!EGL.eglGetConfigs(eglDisplay.getHandle(), null, 0, numConfigs)) {
throw new GLException(
"EGLDrawableFactory.getAvailableEGLConfigs: Get maxConfigs (eglGetConfigs) call failed, error "
+ EGLContext.toHexString(EGL.eglGetError()));
}
if (0 < numConfigs.get(0)) {
final PointerBuffer configs = PointerBuffer.allocateDirect(numConfigs.get(0));
final IntBuffer attrs = EGLGraphicsConfiguration.GLCapabilities2AttribList(caps);
final int winattrmask = GLGraphicsConfigurationUtil.getExclusiveWinAttributeBits(caps);
if (EGL.eglChooseConfig(
eglDisplay.getHandle(), attrs, configs, configs.capacity(), numConfigs)
&& numConfigs.get(0) > 0) {
return EGLGraphicsConfigurationFactory.eglConfigs2GLCaps(
eglDisplay,
caps.getGLProfile(),
configs,
numConfigs.get(0),
winattrmask,
false /* forceTransparentFlag */);
}
}
return new ArrayList<GLCapabilitiesImmutable>(0);
}
private final void evalUpstreamSurface(String dbgPrefix, ProxySurface surface) {
//
// evaluate nature of upstreamSurface, may create EGL instances if required
//
boolean isEGLSurfaceValid = true; // assume yes
final EGLGraphicsDevice eglDevice;
final AbstractGraphicsConfiguration aConfig;
{
final AbstractGraphicsConfiguration surfaceConfig = surface.getGraphicsConfiguration();
final AbstractGraphicsDevice surfaceDevice =
null != surfaceConfig ? surfaceConfig.getScreen().getDevice() : null;
if (DEBUG) {
System.err.println(
dbgPrefix
+ "SurfaceDevice: "
+ surfaceDevice.getClass().getSimpleName()
+ ", hash 0x"
+ Integer.toHexString(surfaceDevice.hashCode())
+ ", "
+ surfaceDevice);
System.err.println(
dbgPrefix
+ "SurfaceConfig: "
+ surfaceConfig.getClass().getSimpleName()
+ ", hash 0x"
+ Integer.toHexString(surfaceConfig.hashCode())
+ ", "
+ surfaceConfig);
}
final AbstractGraphicsConfiguration upstreamConfig =
upstreamSurface.getGraphicsConfiguration();
final AbstractGraphicsDevice upstreamDevice = upstreamConfig.getScreen().getDevice();
if (DEBUG) {
System.err.println(
dbgPrefix
+ "UpstreamDevice: "
+ upstreamDevice.getClass().getSimpleName()
+ ", hash 0x"
+ Integer.toHexString(upstreamDevice.hashCode())
+ ", "
+ upstreamDevice);
System.err.println(
dbgPrefix
+ "UpstreamConfig: "
+ upstreamConfig.getClass().getSimpleName()
+ ", hash 0x"
+ Integer.toHexString(upstreamConfig.hashCode())
+ ", "
+ upstreamConfig);
}
if (surfaceDevice instanceof EGLGraphicsDevice) {
eglDevice = (EGLGraphicsDevice) surfaceDevice;
aConfig = surfaceConfig;
if (DEBUG) {
System.err.println(
dbgPrefix
+ "Reusing this eglDevice: "
+ eglDevice
+ ", using this config "
+ aConfig.getClass().getSimpleName()
+ " "
+ aConfig);
}
if (EGL.EGL_NO_DISPLAY == eglDevice.getHandle()) {
eglDevice.open();
isEGLSurfaceValid = false;
surface.addUpstreamOptionBits(ProxySurface.OPT_PROXY_OWNS_UPSTREAM_DEVICE);
}
} else if (upstreamDevice instanceof EGLGraphicsDevice) {
eglDevice = (EGLGraphicsDevice) upstreamDevice;
aConfig = upstreamConfig;
if (DEBUG) {
System.err.println(
dbgPrefix
+ "Reusing upstream eglDevice: "
+ eglDevice
+ ", using upstream config "
+ aConfig.getClass().getSimpleName()
+ " "
+ aConfig);
}
if (EGL.EGL_NO_DISPLAY == eglDevice.getHandle()) {
eglDevice.open();
isEGLSurfaceValid = false;
surface.addUpstreamOptionBits(ProxySurface.OPT_PROXY_OWNS_UPSTREAM_DEVICE);
}
} else {
eglDevice = EGLDisplayUtil.eglCreateEGLGraphicsDevice(upstreamSurface);
eglDevice.open();
aConfig = upstreamConfig;
isEGLSurfaceValid = false;
surface.addUpstreamOptionBits(ProxySurface.OPT_PROXY_OWNS_UPSTREAM_DEVICE);
}
}
final GLCapabilitiesImmutable capsRequested =
(GLCapabilitiesImmutable) aConfig.getRequestedCapabilities();
final EGLGraphicsConfiguration eglConfig;
if (aConfig instanceof EGLGraphicsConfiguration) {
// Config is already in EGL type - reuse ..
final EGLGLCapabilities capsChosen = (EGLGLCapabilities) aConfig.getChosenCapabilities();
if (!isEGLSurfaceValid
|| !EGLGraphicsConfiguration.isEGLConfigValid(
eglDevice.getHandle(), capsChosen.getEGLConfig())) {
// 'refresh' the native EGLConfig handle
capsChosen.setEGLConfig(
EGLGraphicsConfiguration.EGLConfigId2EGLConfig(
eglDevice.getHandle(), capsChosen.getEGLConfigID()));
if (0 == capsChosen.getEGLConfig()) {
throw new GLException(
"Refreshing native EGLConfig handle failed with error "
+ EGLContext.toHexString(EGL.eglGetError())
+ ": "
+ eglDevice
+ ", "
+ capsChosen
+ " of "
+ aConfig);
}
final AbstractGraphicsScreen eglScreen =
new DefaultGraphicsScreen(eglDevice, aConfig.getScreen().getIndex());
eglConfig = new EGLGraphicsConfiguration(eglScreen, capsChosen, capsRequested, null);
if (DEBUG) {
System.err.println(dbgPrefix + "Refreshing eglConfig: " + eglConfig);
}
isEGLSurfaceValid = false;
} else {
eglConfig = (EGLGraphicsConfiguration) aConfig;
if (DEBUG) {
System.err.println(dbgPrefix + "Reusing eglConfig: " + eglConfig);
}
}
} else {
final AbstractGraphicsScreen eglScreen =
new DefaultGraphicsScreen(eglDevice, aConfig.getScreen().getIndex());
eglConfig =
EGLGraphicsConfigurationFactory.chooseGraphicsConfigurationStatic(
capsRequested,
capsRequested,
null,
eglScreen,
aConfig.getVisualID(VIDType.NATIVE),
false /* forceTransparencyFlag */);
if (null == eglConfig) {
throw new GLException("Couldn't create EGLGraphicsConfiguration from " + eglScreen);
} else if (DEBUG) {
System.err.println(dbgPrefix + "Chosen eglConfig: " + eglConfig);
}
isEGLSurfaceValid = false;
}
surface.setGraphicsConfiguration(eglConfig);
if (isEGLSurfaceValid) {
isEGLSurfaceValid =
EGLDrawable.isValidEGLSurface(eglDevice.getHandle(), upstreamSurface.getSurfaceHandle());
}
if (isEGLSurfaceValid) {
surface.setSurfaceHandle(upstreamSurface.getSurfaceHandle());
surface.clearUpstreamOptionBits(ProxySurface.OPT_PROXY_OWNS_UPSTREAM_SURFACE);
if (DEBUG) {
System.err.println(
dbgPrefix + "Fin: Already valid EGL surface - use as-is: " + upstreamSurface);
}
} else {
surface.setSurfaceHandle(EGL.EGL_NO_SURFACE);
surface.addUpstreamOptionBits(
ProxySurface.OPT_PROXY_OWNS_UPSTREAM_SURFACE); // create/destroy in EGLDrawable
if (DEBUG) {
System.err.println(dbgPrefix + "Fin: EGL surface n/a - TBD: " + upstreamSurface);
}
}
}