Examples with EGLConfig javax.microedition.khronos.egl.EGLConfig used on opensource projects

Example 6 with EGLConfig

use of javax.microedition.khronos.egl.EGLConfig in project Signal-Android by WhisperSystems.

the class BitmapUtil method getMaxTextureSize.

public static int getMaxTextureSize() {
    final int IMAGE_MAX_BITMAP_DIMENSION = 2048;
    EGL10 egl = (EGL10) EGLContext.getEGL();
    EGLDisplay display = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
    int[] version = new int[2];
    egl.eglInitialize(display, version);
    int[] totalConfigurations = new int[1];
    egl.eglGetConfigs(display, null, 0, totalConfigurations);
    EGLConfig[] configurationsList = new EGLConfig[totalConfigurations[0]];
    egl.eglGetConfigs(display, configurationsList, totalConfigurations[0], totalConfigurations);
    int[] textureSize = new int[1];
    int maximumTextureSize = 0;
    for (int i = 0; i < totalConfigurations[0]; i++) {
        egl.eglGetConfigAttrib(display, configurationsList[i], EGL10.EGL_MAX_PBUFFER_WIDTH, textureSize);
        if (maximumTextureSize < textureSize[0])
            maximumTextureSize = textureSize[0];
    }
    egl.eglTerminate(display);
    return Math.max(maximumTextureSize, IMAGE_MAX_BITMAP_DIMENSION);
}

Example 7 with EGLConfig

use of javax.microedition.khronos.egl.EGLConfig in project Rajawali by Rajawali.

the class RajawaliEGLConfigChooser method chooseConfig.

@Override
public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
    int[] result = new int[1];
    if (!egl.eglChooseConfig(display, mConfigSpec, null, 0, result)) {
        throw new IllegalStateException("This device does not support the requested EGL Configuration!");
    }
    EGLConfig[] configs = new EGLConfig[result[0]];
    if (!egl.eglChooseConfig(display, mConfigSpec, configs, result[0], result)) {
        throw new RuntimeException("Couldn't create EGL configuration.");
    }
    int index = -1;
    int[] value = new int[1];
    for (int i = 0; i < configs.length; ++i) {
        egl.eglGetConfigAttrib(display, configs[i], EGL10.EGL_RED_SIZE, value);
        if (value[0] == mConfigSpec[1]) {
            index = i;
            break;
        }
    }
    EGLConfig config = configs.length > 0 ? configs[index] : null;
    if (config == null) {
        throw new RuntimeException("No EGL configuration chosen");
    }
    return config;
}

Example 8 with EGLConfig

use of javax.microedition.khronos.egl.EGLConfig in project android-gpuimage-ndkbuild-sample by mugku.

the class PixelBuffer method listConfig.

private void listConfig() {
    Log.i(TAG, "Config List {");
    for (EGLConfig config : mEGLConfigs) {
        int d, s, r, g, b, a;
        // Expand on this logic to dump other attributes
        d = getConfigAttrib(config, EGL_DEPTH_SIZE);
        s = getConfigAttrib(config, EGL_STENCIL_SIZE);
        r = getConfigAttrib(config, EGL_RED_SIZE);
        g = getConfigAttrib(config, EGL_GREEN_SIZE);
        b = getConfigAttrib(config, EGL_BLUE_SIZE);
        a = getConfigAttrib(config, EGL_ALPHA_SIZE);
        Log.i(TAG, "    <d,s,r,g,b,a> = <" + d + "," + s + "," + r + "," + g + "," + b + "," + a + ">");
    }
    Log.i(TAG, "}");
}

Example 9 with EGLConfig

use of javax.microedition.khronos.egl.EGLConfig in project CameraFilter by nekocode.

the class CameraRenderer method initGL.

private void initGL(SurfaceTexture texture) {
    egl10 = (EGL10) EGLContext.getEGL();
    eglDisplay = egl10.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
    if (eglDisplay == EGL10.EGL_NO_DISPLAY) {
        throw new RuntimeException("eglGetDisplay failed " + android.opengl.GLUtils.getEGLErrorString(egl10.eglGetError()));
    }
    int[] version = new int[2];
    if (!egl10.eglInitialize(eglDisplay, version)) {
        throw new RuntimeException("eglInitialize failed " + android.opengl.GLUtils.getEGLErrorString(egl10.eglGetError()));
    }
    int[] configsCount = new int[1];
    EGLConfig[] configs = new EGLConfig[1];
    int[] configSpec = { EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL10.EGL_RED_SIZE, 8, EGL10.EGL_GREEN_SIZE, 8, EGL10.EGL_BLUE_SIZE, 8, EGL10.EGL_ALPHA_SIZE, 8, EGL10.EGL_DEPTH_SIZE, 0, EGL10.EGL_STENCIL_SIZE, 0, EGL10.EGL_NONE };
    EGLConfig eglConfig = null;
    if (!egl10.eglChooseConfig(eglDisplay, configSpec, configs, 1, configsCount)) {
        throw new IllegalArgumentException("eglChooseConfig failed " + android.opengl.GLUtils.getEGLErrorString(egl10.eglGetError()));
    } else if (configsCount[0] > 0) {
        eglConfig = configs[0];
    }
    if (eglConfig == null) {
        throw new RuntimeException("eglConfig not initialized");
    }
    int[] attrib_list = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
    eglContext = egl10.eglCreateContext(eglDisplay, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
    eglSurface = egl10.eglCreateWindowSurface(eglDisplay, eglConfig, texture, null);
    if (eglSurface == null || eglSurface == EGL10.EGL_NO_SURFACE) {
        int error = egl10.eglGetError();
        if (error == EGL10.EGL_BAD_NATIVE_WINDOW) {
            Log.e(TAG, "eglCreateWindowSurface returned EGL10.EGL_BAD_NATIVE_WINDOW");
            return;
        }
        throw new RuntimeException("eglCreateWindowSurface failed " + android.opengl.GLUtils.getEGLErrorString(error));
    }
    if (!egl10.eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext)) {
        throw new RuntimeException("eglMakeCurrent failed " + android.opengl.GLUtils.getEGLErrorString(egl10.eglGetError()));
    }
}

Example 10 with EGLConfig

use of javax.microedition.khronos.egl.EGLConfig in project android_frameworks_base by ResurrectionRemix.

the class SingleFrameTextureViewTestActivity method onSurfaceTextureAvailable.

@Override
public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
    Log.d(LOG_TAG, "onSurfaceAvailable");
    mGLThread = new Thread() {

        static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;

        static final int EGL_OPENGL_ES2_BIT = 4;

        private EGL10 mEgl;

        private EGLDisplay mEglDisplay;

        private EGLConfig mEglConfig;

        private EGLContext mEglContext;

        private EGLSurface mEglSurface;

        @Override
        public void run() {
            initGL();
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
            for (int i = 0; i < 2; i++) {
                if (i == 0) {
                    glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
                } else {
                    glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
                }
                glClear(GL_COLOR_BUFFER_BIT);
                Log.d(LOG_TAG, "eglSwapBuffers");
                if (!mEgl.eglSwapBuffers(mEglDisplay, mEglSurface)) {
                    throw new RuntimeException("Cannot swap buffers");
                }
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                }
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
            finishGL();
        }

        private void finishGL() {
            mEgl.eglDestroyContext(mEglDisplay, mEglContext);
            mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
        }

        private void initGL() {
            mEgl = (EGL10) EGLContext.getEGL();
            mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
            if (mEglDisplay == EGL10.EGL_NO_DISPLAY) {
                throw new RuntimeException("eglGetDisplay failed " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
            }
            int[] version = new int[2];
            if (!mEgl.eglInitialize(mEglDisplay, version)) {
                throw new RuntimeException("eglInitialize failed " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
            }
            mEglConfig = chooseEglConfig();
            if (mEglConfig == null) {
                throw new RuntimeException("eglConfig not initialized");
            }
            mEglContext = createContext(mEgl, mEglDisplay, mEglConfig);
            mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay, mEglConfig, surface, null);
            if (mEglSurface == null || mEglSurface == EGL10.EGL_NO_SURFACE) {
                int error = mEgl.eglGetError();
                if (error == EGL10.EGL_BAD_NATIVE_WINDOW) {
                    Log.e(LOG_TAG, "createWindowSurface returned EGL_BAD_NATIVE_WINDOW.");
                    return;
                }
                throw new RuntimeException("createWindowSurface failed " + GLUtils.getEGLErrorString(error));
            }
            if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
                throw new RuntimeException("eglMakeCurrent failed " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
            }
        }

        EGLContext createContext(EGL10 egl, EGLDisplay eglDisplay, EGLConfig eglConfig) {
            int[] attrib_list = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
            return egl.eglCreateContext(eglDisplay, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
        }

        private EGLConfig chooseEglConfig() {
            int[] configsCount = new int[1];
            EGLConfig[] configs = new EGLConfig[1];
            int[] configSpec = getConfig();
            if (!mEgl.eglChooseConfig(mEglDisplay, configSpec, configs, 1, configsCount)) {
                throw new IllegalArgumentException("eglChooseConfig failed " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
            } else if (configsCount[0] > 0) {
                return configs[0];
            }
            return null;
        }

        private int[] getConfig() {
            return new int[] { EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL10.EGL_RED_SIZE, 8, EGL10.EGL_GREEN_SIZE, 8, EGL10.EGL_BLUE_SIZE, 8, EGL10.EGL_ALPHA_SIZE, 8, EGL10.EGL_DEPTH_SIZE, 0, EGL10.EGL_STENCIL_SIZE, 0, EGL10.EGL_NONE };
        }
    };
    mGLThread.start();
}