Source code
Revision control
Copy as Markdown
Other Tools
/*
* Copyright 2015 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
package org.webrtc;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.graphics.SurfaceTexture;
import android.opengl.GLException;
import android.view.Surface;
import android.view.SurfaceHolder;
import androidx.annotation.Nullable;
import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;
import javax.microedition.khronos.egl.EGLSurface;
/**
* Holds EGL state and utility methods for handling an egl 1.0 EGLContext, an EGLDisplay,
* and an EGLSurface.
*/
class EglBase10Impl implements EglBase10 {
private static final String TAG = "EglBase10Impl";
// This constant is taken from EGL14.EGL_CONTEXT_CLIENT_VERSION.
private static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
private static final EglConnection EGL_NO_CONNECTION = new EglConnection();
private EGLSurface eglSurface = EGL10.EGL_NO_SURFACE;
private EglConnection eglConnection;
// EGL wrapper for an actual EGLContext.
private static class Context implements EglBase10.Context {
private final EGL10 egl;
private final EGLContext eglContext;
private final EGLConfig eglContextConfig;
@Override
public EGLContext getRawContext() {
return eglContext;
}
@Override
public long getNativeEglContext() {
EGLContext previousContext = egl.eglGetCurrentContext();
EGLDisplay currentDisplay = egl.eglGetCurrentDisplay();
EGLSurface previousDrawSurface = egl.eglGetCurrentSurface(EGL10.EGL_DRAW);
EGLSurface previousReadSurface = egl.eglGetCurrentSurface(EGL10.EGL_READ);
EGLSurface tempEglSurface = null;
if (currentDisplay == EGL10.EGL_NO_DISPLAY) {
currentDisplay = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
}
try {
if (previousContext != eglContext) {
int[] surfaceAttribs = {EGL10.EGL_WIDTH, 1, EGL10.EGL_HEIGHT, 1, EGL10.EGL_NONE};
tempEglSurface =
egl.eglCreatePbufferSurface(currentDisplay, eglContextConfig, surfaceAttribs);
if (!egl.eglMakeCurrent(currentDisplay, tempEglSurface, tempEglSurface, eglContext)) {
throw new GLException(egl.eglGetError(),
"Failed to make temporary EGL surface active: " + egl.eglGetError());
}
}
return nativeGetCurrentNativeEGLContext();
} finally {
if (tempEglSurface != null) {
egl.eglMakeCurrent(
currentDisplay, previousDrawSurface, previousReadSurface, previousContext);
egl.eglDestroySurface(currentDisplay, tempEglSurface);
}
}
}
public Context(EGL10 egl, EGLContext eglContext, EGLConfig eglContextConfig) {
this.egl = egl;
this.eglContext = eglContext;
this.eglContextConfig = eglContextConfig;
}
}
public static class EglConnection implements EglBase10.EglConnection {
private final EGL10 egl;
private final EGLContext eglContext;
private final EGLDisplay eglDisplay;
private final EGLConfig eglConfig;
private final RefCountDelegate refCountDelegate;
private EGLSurface currentSurface = EGL10.EGL_NO_SURFACE;
public EglConnection(EGLContext sharedContext, int[] configAttributes) {
egl = (EGL10) EGLContext.getEGL();
eglDisplay = getEglDisplay(egl);
eglConfig = getEglConfig(egl, eglDisplay, configAttributes);
final int openGlesVersion = EglBase.getOpenGlesVersionFromConfig(configAttributes);
Logging.d(TAG, "Using OpenGL ES version " + openGlesVersion);
eglContext = createEglContext(egl, sharedContext, eglDisplay, eglConfig, openGlesVersion);
// Ref count delegate with release callback.
refCountDelegate = new RefCountDelegate(() -> {
synchronized (EglBase.lock) {
egl.eglMakeCurrent(
eglDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
}
egl.eglDestroyContext(eglDisplay, eglContext);
egl.eglTerminate(eglDisplay);
currentSurface = EGL10.EGL_NO_SURFACE;
});
}
// Returns a "null" EglConnection. Useful to represent a released instance with default values.
private EglConnection() {
egl = (EGL10) EGLContext.getEGL();
eglContext = EGL10.EGL_NO_CONTEXT;
eglDisplay = EGL10.EGL_NO_DISPLAY;
eglConfig = null;
refCountDelegate = new RefCountDelegate(() -> {});
}
@Override
public void retain() {
refCountDelegate.retain();
}
@Override
public void release() {
refCountDelegate.release();
}
@Override
public EGL10 getEgl() {
return egl;
}
@Override
public EGLContext getContext() {
return eglContext;
}
@Override
public EGLDisplay getDisplay() {
return eglDisplay;
}
@Override
public EGLConfig getConfig() {
return eglConfig;
}
public void makeCurrent(EGLSurface eglSurface) {
if (egl.eglGetCurrentContext() == eglContext && currentSurface == eglSurface) {
return;
}
synchronized (EglBase.lock) {
if (!egl.eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext)) {
throw new GLException(egl.eglGetError(),
"eglMakeCurrent failed: 0x" + Integer.toHexString(egl.eglGetError()));
}
}
currentSurface = eglSurface;
}
public void detachCurrent() {
synchronized (EglBase.lock) {
if (!egl.eglMakeCurrent(
eglDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT)) {
throw new GLException(egl.eglGetError(),
"eglDetachCurrent failed: 0x" + Integer.toHexString(egl.eglGetError()));
}
}
currentSurface = EGL10.EGL_NO_SURFACE;
}
}
// Create a new context with the specified config type, sharing data with sharedContext.
public EglBase10Impl(EGLContext sharedContext, int[] configAttributes) {
this.eglConnection = new EglConnection(sharedContext, configAttributes);
}
public EglBase10Impl(EglConnection eglConnection) {
this.eglConnection = eglConnection;
this.eglConnection.retain();
}
@Override
public void createSurface(Surface surface) {
/**
* We have to wrap Surface in a SurfaceHolder because for some reason eglCreateWindowSurface
* couldn't actually take a Surface object until API 17. Older versions fortunately just call
* SurfaceHolder.getSurface(), so we'll do that. No other methods are relevant.
*/
class FakeSurfaceHolder implements SurfaceHolder {
private final Surface surface;
FakeSurfaceHolder(Surface surface) {
this.surface = surface;
}
@Override
public void addCallback(Callback callback) {}
@Override
public void removeCallback(Callback callback) {}
@Override
public boolean isCreating() {
return false;
}
@Deprecated
@Override
public void setType(int i) {}
@Override
public void setFixedSize(int i, int i2) {}
@Override
public void setSizeFromLayout() {}
@Override
public void setFormat(int i) {}
@Override
public void setKeepScreenOn(boolean b) {}
@Nullable
@Override
public Canvas lockCanvas() {
return null;
}
@Nullable
@Override
public Canvas lockCanvas(Rect rect) {
return null;
}
@Override
public void unlockCanvasAndPost(Canvas canvas) {}
@Nullable
@Override
public Rect getSurfaceFrame() {
return null;
}
@Override
public Surface getSurface() {
return surface;
}
}
createSurfaceInternal(new FakeSurfaceHolder(surface));
}
// Create EGLSurface from the Android SurfaceTexture.
@Override
public void createSurface(SurfaceTexture surfaceTexture) {
createSurfaceInternal(surfaceTexture);
}
// Create EGLSurface from either a SurfaceHolder or a SurfaceTexture.
private void createSurfaceInternal(Object nativeWindow) {
if (!(nativeWindow instanceof SurfaceHolder) && !(nativeWindow instanceof SurfaceTexture)) {
throw new IllegalStateException("Input must be either a SurfaceHolder or SurfaceTexture");
}
checkIsNotReleased();
if (eglSurface != EGL10.EGL_NO_SURFACE) {
throw new RuntimeException("Already has an EGLSurface");
}
EGL10 egl = eglConnection.getEgl();
int[] surfaceAttribs = {EGL10.EGL_NONE};
eglSurface = egl.eglCreateWindowSurface(
eglConnection.getDisplay(), eglConnection.getConfig(), nativeWindow, surfaceAttribs);
if (eglSurface == EGL10.EGL_NO_SURFACE) {
throw new GLException(egl.eglGetError(),
"Failed to create window surface: 0x" + Integer.toHexString(egl.eglGetError()));
}
}
// Create dummy 1x1 pixel buffer surface so the context can be made current.
@Override
public void createDummyPbufferSurface() {
createPbufferSurface(1, 1);
}
@Override
public void createPbufferSurface(int width, int height) {
checkIsNotReleased();
if (eglSurface != EGL10.EGL_NO_SURFACE) {
throw new RuntimeException("Already has an EGLSurface");
}
EGL10 egl = eglConnection.getEgl();
int[] surfaceAttribs = {EGL10.EGL_WIDTH, width, EGL10.EGL_HEIGHT, height, EGL10.EGL_NONE};
eglSurface = egl.eglCreatePbufferSurface(
eglConnection.getDisplay(), eglConnection.getConfig(), surfaceAttribs);
if (eglSurface == EGL10.EGL_NO_SURFACE) {
throw new GLException(egl.eglGetError(),
"Failed to create pixel buffer surface with size " + width + "x" + height + ": 0x"
+ Integer.toHexString(egl.eglGetError()));
}
}
@Override
public org.webrtc.EglBase.Context getEglBaseContext() {
return new Context(
eglConnection.getEgl(), eglConnection.getContext(), eglConnection.getConfig());
}
@Override
public boolean hasSurface() {
return eglSurface != EGL10.EGL_NO_SURFACE;
}
@Override
public int surfaceWidth() {
final int widthArray[] = new int[1];
eglConnection.getEgl().eglQuerySurface(
eglConnection.getDisplay(), eglSurface, EGL10.EGL_WIDTH, widthArray);
return widthArray[0];
}
@Override
public int surfaceHeight() {
final int heightArray[] = new int[1];
eglConnection.getEgl().eglQuerySurface(
eglConnection.getDisplay(), eglSurface, EGL10.EGL_HEIGHT, heightArray);
return heightArray[0];
}
@Override
public void releaseSurface() {
if (eglSurface != EGL10.EGL_NO_SURFACE) {
eglConnection.getEgl().eglDestroySurface(eglConnection.getDisplay(), eglSurface);
eglSurface = EGL10.EGL_NO_SURFACE;
}
}
private void checkIsNotReleased() {
if (eglConnection == EGL_NO_CONNECTION) {
throw new RuntimeException("This object has been released");
}
}
@Override
public void release() {
checkIsNotReleased();
releaseSurface();
eglConnection.release();
eglConnection = EGL_NO_CONNECTION;
}
@Override
public void makeCurrent() {
checkIsNotReleased();
if (eglSurface == EGL10.EGL_NO_SURFACE) {
throw new RuntimeException("No EGLSurface - can't make current");
}
eglConnection.makeCurrent(eglSurface);
}
// Detach the current EGL context, so that it can be made current on another thread.
@Override
public void detachCurrent() {
eglConnection.detachCurrent();
}
@Override
public void swapBuffers() {
checkIsNotReleased();
if (eglSurface == EGL10.EGL_NO_SURFACE) {
throw new RuntimeException("No EGLSurface - can't swap buffers");
}
synchronized (EglBase.lock) {
eglConnection.getEgl().eglSwapBuffers(eglConnection.getDisplay(), eglSurface);
}
}
@Override
public void swapBuffers(long timeStampNs) {
// Setting presentation time is not supported for EGL 1.0.
swapBuffers();
}
// Return an EGLDisplay, or die trying.
private static EGLDisplay getEglDisplay(EGL10 egl) {
EGLDisplay eglDisplay = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
if (eglDisplay == EGL10.EGL_NO_DISPLAY) {
throw new GLException(egl.eglGetError(),
"Unable to get EGL10 display: 0x" + Integer.toHexString(egl.eglGetError()));
}
int[] version = new int[2];
if (!egl.eglInitialize(eglDisplay, version)) {
throw new GLException(egl.eglGetError(),
"Unable to initialize EGL10: 0x" + Integer.toHexString(egl.eglGetError()));
}
return eglDisplay;
}
// Return an EGLConfig, or die trying.
private static EGLConfig getEglConfig(EGL10 egl, EGLDisplay eglDisplay, int[] configAttributes) {
EGLConfig[] configs = new EGLConfig[1];
int[] numConfigs = new int[1];
if (!egl.eglChooseConfig(eglDisplay, configAttributes, configs, configs.length, numConfigs)) {
throw new GLException(
egl.eglGetError(), "eglChooseConfig failed: 0x" + Integer.toHexString(egl.eglGetError()));
}
if (numConfigs[0] <= 0) {
throw new RuntimeException("Unable to find any matching EGL config");
}
final EGLConfig eglConfig = configs[0];
if (eglConfig == null) {
throw new RuntimeException("eglChooseConfig returned null");
}
return eglConfig;
}
// Return an EGLConfig, or die trying.
private static EGLContext createEglContext(EGL10 egl, @Nullable EGLContext sharedContext,
EGLDisplay eglDisplay, EGLConfig eglConfig, int openGlesVersion) {
if (sharedContext != null && sharedContext == EGL10.EGL_NO_CONTEXT) {
throw new RuntimeException("Invalid sharedContext");
}
int[] contextAttributes = {EGL_CONTEXT_CLIENT_VERSION, openGlesVersion, EGL10.EGL_NONE};
EGLContext rootContext = sharedContext == null ? EGL10.EGL_NO_CONTEXT : sharedContext;
final EGLContext eglContext;
synchronized (EglBase.lock) {
eglContext = egl.eglCreateContext(eglDisplay, eglConfig, rootContext, contextAttributes);
}
if (eglContext == EGL10.EGL_NO_CONTEXT) {
throw new GLException(egl.eglGetError(),
"Failed to create EGL context: 0x" + Integer.toHexString(egl.eglGetError()));
}
return eglContext;
}
private static native long nativeGetCurrentNativeEGLContext();
}