Distorted Android

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.examples.plainmonalisa;

import android.graphics.SurfaceTexture;

import android.opengl.EGL14;

import android.opengl.EGLConfig;

import android.opengl.EGLContext;

import android.opengl.EGLDisplay;

import android.opengl.EGLExt;

import android.opengl.EGLSurface;

import android.os.Build;

import android.util.Log;

import android.view.Surface;

///////////////////////////////////////////////////////////////////////////////////////////////////

public final class EglCore

  {

  private static final String TAG = "EglCore";

  public static final int FLAG_RECORDABLE = 0x01;           // Surface must be recordable.  This discourages EGL from using a

                                                            // pixel format that cannot be converted efficiently to something 

                                                            // usable by the video encoder.

  public static final int FLAG_TRY_GLES3 = 0x02;            // Ask for GLES3, fall back to GLES2 if not available.

  private static final int EGL_RECORDABLE_ANDROID = 0x3142; // Android-specific extension

  private EGLDisplay mEGLDisplay = EGL14.EGL_NO_DISPLAY;

  private EGLContext mEGLContext = EGL14.EGL_NO_CONTEXT;

  private EGLConfig mEGLConfig = null;

  private int mGlVersion = -1;

///////////////////////////////////////////////////////////////////////////////////////////////////

  public EglCore()

    {

    this(null, 0);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public EglCore(EGLContext sharedContext, int flags)

    {

    if (mEGLDisplay != EGL14.EGL_NO_DISPLAY)

      {

      throw new RuntimeException("EGL already set up");

      }

    if (sharedContext == null)

      {

      sharedContext = EGL14.EGL_NO_CONTEXT;

      }

    mEGLDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);

    if (mEGLDisplay == EGL14.EGL_NO_DISPLAY)

      {

      throw new RuntimeException("unable to get EGL14 display");

      }

    int[] version = new int[2];

    if (!EGL14.eglInitialize(mEGLDisplay, version, 0, version, 1))

      {

      mEGLDisplay = null;

      throw new RuntimeException("unable to initialize EGL14");

      }

    // Try to get a GLES3 context, if requested.

    if ((flags & FLAG_TRY_GLES3) != 0)

      {

      //Log.d(TAG, "Trying GLES 3");

      EGLConfig config = getConfig(flags, 3);

      if (config != null)

        {

        int[] attrib3_list =  { EGL14.EGL_CONTEXT_CLIENT_VERSION, 3, EGL14.EGL_NONE };

        EGLContext context = EGL14.eglCreateContext(mEGLDisplay, config, sharedContext, attrib3_list, 0);

        if (EGL14.eglGetError() == EGL14.EGL_SUCCESS)

          {

          //Log.d(TAG, "Got GLES 3 config");

          mEGLConfig = config;

          mEGLContext = context;

          mGlVersion = 3;

          }

        }

      }

    if (mEGLContext == EGL14.EGL_NO_CONTEXT)

      {  // GLES 2 only, or GLES 3 attempt failed

         //Log.d(TAG, "Trying GLES 2");

      EGLConfig config = getConfig(flags, 2);

      if (config == null)

        {

        throw new RuntimeException("Unable to find a suitable EGLConfig");

        }

      int[] attrib2_list = { EGL14.EGL_CONTEXT_CLIENT_VERSION, 2, EGL14.EGL_NONE };

      EGLContext context = EGL14.eglCreateContext(mEGLDisplay, config, sharedContext, attrib2_list, 0);

      checkEglError("eglCreateContext");

      mEGLConfig = config;

      mEGLContext = context;

      mGlVersion = 2;

      }

    // Confirm with query.

    int[] values = new int[1];

    EGL14.eglQueryContext(mEGLDisplay, mEGLContext, EGL14.EGL_CONTEXT_CLIENT_VERSION, values, 0);

    Log.d(TAG, "EGLContext created, client version " + values[0]);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private EGLConfig getConfig(int flags, int version)

    {

    int renderableType = EGL14.EGL_OPENGL_ES2_BIT;

    if (version >= 3)

      {

      renderableType |= EGLExt.EGL_OPENGL_ES3_BIT_KHR;

      }

    // The actual surface is generally RGBA or RGBX, so situationally omitting alpha

    // doesn't really help.  It can also lead to a huge performance hit on glReadPixels()

    // when reading into a GL_RGBA buffer.

    int [] normalAttribList =

                {

                EGL14.EGL_RED_SIZE, 8,

                EGL14.EGL_GREEN_SIZE, 8,

                EGL14.EGL_BLUE_SIZE, 8,

                EGL14.EGL_ALPHA_SIZE, 8,

                EGL14.EGL_RENDERABLE_TYPE, renderableType,

                EGL14.EGL_NONE, 0,      // placeholder for recordable [@-3]

                EGL14.EGL_NONE

                };

    if ((flags & FLAG_RECORDABLE) != 0)

      {

      normalAttribList[normalAttribList.length - 3] = EGL_RECORDABLE_ANDROID;

      normalAttribList[normalAttribList.length - 2] = 1;

      }

    int [] emulatorAttribList =

                {

                EGL14.EGL_RED_SIZE, 8,

                EGL14.EGL_GREEN_SIZE, 8,

                EGL14.EGL_BLUE_SIZE, 8,

                EGL14.EGL_ALPHA_SIZE, 8,

                EGL14.EGL_DEPTH_SIZE, 16,

                EGL14.EGL_STENCIL_SIZE, 0,

                EGL14.EGL_NONE

                };

    boolean isEmulator=

               Build.FINGERPRINT.startsWith("generic")

            || Build.FINGERPRINT.startsWith("unknown")

            || Build.MODEL.contains("google_sdk")

            || Build.MODEL.contains("Emulator")

            || Build.MODEL.contains("Android SDK built for x86")

            || Build.MANUFACTURER.contains("Genymotion")

            || (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic"))

            || "google_sdk".equals(Build.PRODUCT);

    int [] attribList = (isEmulator ? emulatorAttribList:normalAttribList);

    if( isEmulator )

      {

      Log.w(TAG, "Using emulator config!" );

      }

    EGLConfig[] configs = new EGLConfig[1];

    int[] numConfigs = new int[1];

    if (!EGL14.eglChooseConfig(mEGLDisplay, attribList, 0, configs, 0, configs.length, numConfigs, 0))

      {

      Log.w(TAG, "unable to find RGB8888 / " + version + " EGLConfig");

      return null;

      }

    return configs[0];

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void release()

    {

    if (mEGLDisplay != EGL14.EGL_NO_DISPLAY)

      {

      EGL14.eglMakeCurrent(mEGLDisplay, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT);

      EGL14.eglDestroyContext(mEGLDisplay, mEGLContext);

      EGL14.eglReleaseThread();

      EGL14.eglTerminate(mEGLDisplay);

      }

    mEGLDisplay = EGL14.EGL_NO_DISPLAY;

    mEGLContext = EGL14.EGL_NO_CONTEXT;

    mEGLConfig = null;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  @Override

  protected void finalize() throws Throwable

    {

    try

      {

      if (mEGLDisplay != EGL14.EGL_NO_DISPLAY)

        {

        // We're limited here -- finalizers don't run on the thread that holds

        // the EGL state, so if a surface or context is still current on another

        // thread we can't fully release it here.  Exceptions thrown from here

        // are quietly discarded.  Complain in the log file.

        Log.w(TAG, "WARNING: EglCore was not explicitly released -- state may be leaked");

        release();

        }

      }

    finally

      {

      super.finalize();

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void releaseSurface(EGLSurface eglSurface)

    {

    EGL14.eglDestroySurface(mEGLDisplay, eglSurface);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public EGLSurface createWindowSurface(Object surface)

    {

    if (!(surface instanceof Surface) && !(surface instanceof SurfaceTexture))

      {

      throw new RuntimeException("invalid surface: " + surface);

      }

    int[] surfaceAttribs = { EGL14.EGL_NONE };

    EGLSurface eglSurface = EGL14.eglCreateWindowSurface(mEGLDisplay, mEGLConfig, surface, surfaceAttribs, 0);

    checkEglError("eglCreateWindowSurface");

    if (eglSurface == null)

      {

      throw new RuntimeException("surface was null");

      }

    return eglSurface;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void makeCurrent(EGLSurface eglSurface)

    {

    if (mEGLDisplay == EGL14.EGL_NO_DISPLAY)

      {

      Log.d(TAG, "NOTE: makeCurrent w/o display");

      }

    if (!EGL14.eglMakeCurrent(mEGLDisplay, eglSurface, eglSurface, mEGLContext))

      {

      throw new RuntimeException("eglMakeCurrent failed");

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void makeNothingCurrent()

    {

    if (!EGL14.eglMakeCurrent(mEGLDisplay, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT))

      {

      throw new RuntimeException("eglMakeCurrent failed");

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public int getGlVersion()

    {

    return mGlVersion;

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public boolean swapBuffers(EGLSurface eglSurface)

    {

    return EGL14.eglSwapBuffers(mEGLDisplay, eglSurface);

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  private void checkEglError(String msg)

    {

    int error;

    if ((error = EGL14.eglGetError()) != EGL14.EGL_SUCCESS)

      {

      throw new RuntimeException(msg + ": EGL error: 0x" + Integer.toHexString(error));

      }

    }

  }