xref: /packages/apps/Gallery2/src/com/android/photos/views/BlockingGLTextureView.java

/*
 * Copyright (C) 2013 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.photos.views;

import android.content.Context;
import android.graphics.SurfaceTexture;
import android.opengl.GLSurfaceView.Renderer;
import android.opengl.GLUtils;
import android.util.Log;
import android.view.TextureView;
import android.view.TextureView.SurfaceTextureListener;

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;
import javax.microedition.khronos.opengles.GL10;

/**
 * A TextureView that supports blocking rendering for synchronous drawing
 */
public class BlockingGLTextureView extends TextureView
        implements SurfaceTextureListener {

    private RenderThread mRenderThread;

    public BlockingGLTextureView(Context context) {
        super(context);
        setSurfaceTextureListener(this);
    }

    public void setRenderer(Renderer renderer) {
        if (mRenderThread != null) {
            throw new IllegalArgumentException("Renderer already set");
        }
        mRenderThread = new RenderThread(renderer);
    }

    public void render() {
        mRenderThread.render();
    }

    public void destroy() {
        if (mRenderThread != null) {
            mRenderThread.finish();
            mRenderThread = null;
        }
    }

    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width,
            int height) {
        mRenderThread.setSurface(surface);
        mRenderThread.setSize(width, height);
    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width,
            int height) {
        mRenderThread.setSize(width, height);
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
        if (mRenderThread != null) {
            mRenderThread.setSurface(null);
        }
        return false;
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surface) {
    }

    @Override
    protected void finalize() throws Throwable {
        try {
            destroy();
        } catch (Throwable t) {
            // Ignore
        }
        super.finalize();
    }

    /**
     * An EGL helper class.
     */

    private static class EglHelper {
        private static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
        private static final int EGL_OPENGL_ES2_BIT = 4;

        EGL10 mEgl;
        EGLDisplay mEglDisplay;
        EGLSurface mEglSurface;
        EGLConfig mEglConfig;
        EGLContext mEglContext;

        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 static 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
            };
        }

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

        /**
         * Initialize EGL for a given configuration spec.
         */
        public void start() {
            /*
             * Get an EGL instance
             */
            mEgl = (EGL10) EGLContext.getEGL();

            /*
             * Get to the default display.
             */
            mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);

            if (mEglDisplay == EGL10.EGL_NO_DISPLAY) {
                throw new RuntimeException("eglGetDisplay failed");
            }

            /*
             * We can now initialize EGL for that display
             */
            int[] version = new int[2];
            if (!mEgl.eglInitialize(mEglDisplay, version)) {
                throw new RuntimeException("eglInitialize failed");
            }
            mEglConfig = chooseEglConfig();

            /*
            * Create an EGL context. We want to do this as rarely as we can, because an
            * EGL context is a somewhat heavy object.
            */
            mEglContext = createContext(mEgl, mEglDisplay, mEglConfig);

            if (mEglContext == null || mEglContext == EGL10.EGL_NO_CONTEXT) {
                mEglContext = null;
                throwEglException("createContext");
            }

            mEglSurface = null;
        }

        /**
         * Create an egl surface for the current SurfaceTexture surface. If a surface
         * already exists, destroy it before creating the new surface.
         *
         * @return true if the surface was created successfully.
         */
        public boolean createSurface(SurfaceTexture surface) {
            /*
             * Check preconditions.
             */
            if (mEgl == null) {
                throw new RuntimeException("egl not initialized");
            }
            if (mEglDisplay == null) {
                throw new RuntimeException("eglDisplay not initialized");
            }
            if (mEglConfig == null) {
                throw new RuntimeException("mEglConfig not initialized");
            }

            /*
             *  The window size has changed, so we need to create a new
             *  surface.
             */
            destroySurfaceImp();

            /*
             * Create an EGL surface we can render into.
             */
            if (surface != null) {
                mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay, mEglConfig, surface, null);
            } else {
                mEglSurface = null;
            }

            if (mEglSurface == null || mEglSurface == EGL10.EGL_NO_SURFACE) {
                int error = mEgl.eglGetError();
                if (error == EGL10.EGL_BAD_NATIVE_WINDOW) {
                    Log.e("EglHelper", "createWindowSurface returned EGL_BAD_NATIVE_WINDOW.");
                }
                return false;
            }

            /*
             * Before we can issue GL commands, we need to make sure
             * the context is current and bound to a surface.
             */
            if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
                /*
                 * Could not make the context current, probably because the underlying
                 * SurfaceView surface has been destroyed.
                 */
                logEglErrorAsWarning("EGLHelper", "eglMakeCurrent", mEgl.eglGetError());
                return false;
            }

            return true;
        }

        /**
         * Create a GL object for the current EGL context.
         */
        public GL10 createGL() {
            return (GL10) mEglContext.getGL();
        }

        /**
         * Display the current render surface.
         * @return the EGL error code from eglSwapBuffers.
         */
        public int swap() {
            if (!mEgl.eglSwapBuffers(mEglDisplay, mEglSurface)) {
                return mEgl.eglGetError();
            }
            return EGL10.EGL_SUCCESS;
        }

        public void destroySurface() {
            destroySurfaceImp();
        }

        private void destroySurfaceImp() {
            if (mEglSurface != null && mEglSurface != EGL10.EGL_NO_SURFACE) {
                mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
                        EGL10.EGL_NO_SURFACE,
                        EGL10.EGL_NO_CONTEXT);
                mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
                mEglSurface = null;
            }
        }

        public void finish() {
            if (mEglContext != null) {
                mEgl.eglDestroyContext(mEglDisplay, mEglContext);
                mEglContext = null;
            }
            if (mEglDisplay != null) {
                mEgl.eglTerminate(mEglDisplay);
                mEglDisplay = null;
            }
        }

        private void throwEglException(String function) {
            throwEglException(function, mEgl.eglGetError());
        }

        public static void throwEglException(String function, int error) {
            String message = formatEglError(function, error);
            throw new RuntimeException(message);
        }

        public static void logEglErrorAsWarning(String tag, String function, int error) {
            Log.w(tag, formatEglError(function, error));
        }

        public static String formatEglError(String function, int error) {
            return function + " failed: " + error;
        }

    }

    private static class RenderThread extends Thread {
        private static final int INVALID = -1;
        private static final int RENDER = 1;
        private static final int CHANGE_SURFACE = 2;
        private static final int RESIZE_SURFACE = 3;
        private static final int FINISH = 4;

        private EglHelper mEglHelper = new EglHelper();

        private Object mLock = new Object();
        private int mExecMsgId = INVALID;
        private SurfaceTexture mSurface;
        private Renderer mRenderer;
        private int mWidth, mHeight;

        private boolean mFinished = false;
        private GL10 mGL;

        public RenderThread(Renderer renderer) {
            super("RenderThread");
            mRenderer = renderer;
            start();
        }

        private void checkRenderer() {
            if (mRenderer == null) {
                throw new IllegalArgumentException("Renderer is null!");
            }
        }

        private void checkSurface() {
            if (mSurface == null) {
                throw new IllegalArgumentException("surface is null!");
            }
        }

        public void setSurface(SurfaceTexture surface) {
            // If the surface is null we're being torn down, don't need a
            // renderer then
            if (surface != null) {
                checkRenderer();
            }
            mSurface = surface;
            exec(CHANGE_SURFACE);
        }

        public void setSize(int width, int height) {
            checkRenderer();
            checkSurface();
            mWidth = width;
            mHeight = height;
            exec(RESIZE_SURFACE);
        }

        public void render() {
            checkRenderer();
            if (mSurface != null) {
                exec(RENDER);
                mSurface.updateTexImage();
            }
        }

        public void finish() {
            mSurface = null;
            exec(FINISH);
            try {
                join();
            } catch (InterruptedException e) {
                // Ignore
            }
        }

        private void exec(int msgid) {
            synchronized (mLock) {
                if (mExecMsgId != INVALID) {
                    throw new IllegalArgumentException(
                            "Message already set - multithreaded access?");
                }
                mExecMsgId = msgid;
                mLock.notify();
                try {
                    mLock.wait();
                } catch (InterruptedException e) {
                    // Ignore
                }
            }
        }

        private void handleMessageLocked(int what) {
            switch (what) {
            case CHANGE_SURFACE:
                if (mEglHelper.createSurface(mSurface)) {
                    mGL = mEglHelper.createGL();
                    mRenderer.onSurfaceCreated(mGL, mEglHelper.mEglConfig);
                }
                break;
            case RESIZE_SURFACE:
                mRenderer.onSurfaceChanged(mGL, mWidth, mHeight);
                break;
            case RENDER:
                mRenderer.onDrawFrame(mGL);
                mEglHelper.swap();
                break;
            case FINISH:
                mEglHelper.destroySurface();
                mEglHelper.finish();
                mFinished = true;
                break;
            }
        }

        @Override
        public void run() {
            synchronized (mLock) {
                mEglHelper.start();
                while (!mFinished) {
                    while (mExecMsgId == INVALID) {
                        try {
                            mLock.wait();
                        } catch (InterruptedException e) {
                            // Ignore
                        }
                    }
                    handleMessageLocked(mExecMsgId);
                    mExecMsgId = INVALID;
                    mLock.notify();
                }
                mExecMsgId = FINISH;
            }
        }
    }
}