android.opengl.EGL14 java code examples

private void eglSetup() {
  mEGLDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
  if (mEGLDisplay == EGL14.EGL_NO_DISPLAY) {
    throw new RuntimeException("unable to get EGL14 display");
  if (!EGL14.eglInitialize(mEGLDisplay, version, 0, version, 1)) {
    mEGLDisplay = null;
    throw new RuntimeException("unable to initialize EGL14");
  EGLConfig[] configs = new EGLConfig[1];
  int[] numConfigs = new int[1];
  if (!EGL14.eglChooseConfig(mEGLDisplay, attribList, 0, configs, 0, configs.length,
      numConfigs, 0)) {
    throw new RuntimeException("unable to find RGB888+recordable ES2 EGL config");
      EGL14.EGL_NONE
  };
  mEGLContext = EGL14.eglCreateContext(mEGLDisplay, configs[0], EGL14.eglGetCurrentContext(),
      attrib_list, 0);
  GlUtil.checkEglError("eglCreateContext");
      EGL14.EGL_NONE
  };
  mEGLSurface = EGL14.eglCreateWindowSurface(mEGLDisplay, configs[0], mSurface,
      surfaceAttribs, 0);
  GlUtil.checkEglError("eglCreateWindowSurface");

public void release() {
  EGL14.eglDestroySurface(mEGLDisplay, mEGLSurface);
  EGL14.eglDestroyContext(mEGLDisplay, mEGLContext);
  EGL14.eglReleaseThread();
  EGL14.eglTerminate(mEGLDisplay);
  mSurface.release();
  mSurface    = null;
  mEGLDisplay = null;
  mEGLContext = null;
  mEGLSurface = null;
}

@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
private static int getMaxTextureEgl14() {
  EGLDisplay dpy = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
  int[] vers = new int[2];
  EGL14.eglInitialize(dpy, vers, 0, vers, 1);
  EGLConfig[] configs = new EGLConfig[1];
  int[] numConfig = new int[1];
  EGL14.eglChooseConfig(dpy, configAttr, 0,
      configs, 0, 1, numConfig, 0);
  if (numConfig[0] == 0) {
      EGL14.EGL_NONE
  };
  EGLSurface surf = EGL14.eglCreatePbufferSurface(dpy, config, surfAttr, 0);
      EGL14.EGL_NONE
  };
  EGLContext ctx = EGL14.eglCreateContext(dpy, config, EGL14.EGL_NO_CONTEXT, ctxAttrib, 0);
  EGL14.eglMakeCurrent(dpy, surf, surf, ctx);
  EGL14.eglMakeCurrent(dpy, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE,
      EGL14.EGL_NO_CONTEXT);
  EGL14.eglDestroySurface(dpy, surf);
  EGL14.eglDestroyContext(dpy, ctx);
  EGL14.eglTerminate(dpy);

private static EGLDisplay getDefaultDisplay() {
 EGLDisplay display = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
 if (display == null) {
  throw new GlException("eglGetDisplay failed");
 }
 int[] version = new int[2];
 boolean eglInitialized =
   EGL14.eglInitialize(display, version, /* majorOffset= */ 0, version, /* minorOffset= */ 1);
 if (!eglInitialized) {
  throw new GlException("eglInitialize failed");
 }
 return display;
}

public static void initMediaCodecGL(MediaCodecGLWapper wapper, EGLContext sharedContext, Surface mediaInputSurface) {
  wapper.eglDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
  if (EGL14.EGL_NO_DISPLAY == wapper.eglDisplay) {
    throw new RuntimeException("eglGetDisplay,failed:" + GLUtils.getEGLErrorString(EGL14.eglGetError()));
  if (!EGL14.eglInitialize(wapper.eglDisplay, versions, 0, versions, 1)) {
    throw new RuntimeException("eglInitialize,failed:" + GLUtils.getEGLErrorString(EGL14.eglGetError()));
      EGL14.EGL_NONE
  };
  EGL14.eglChooseConfig(wapper.eglDisplay, configSpec, 0, configs, 0, 1, configsCount, 0);
  if (configsCount[0] <= 0) {
    throw new RuntimeException("eglChooseConfig,failed:" + GLUtils.getEGLErrorString(EGL14.eglGetError()));
      EGL14.EGL_NONE
  };
  wapper.eglContext = EGL14.eglCreateContext(wapper.eglDisplay, wapper.eglConfig, sharedContext, contextSpec, 0);
  if (EGL14.EGL_NO_CONTEXT == wapper.eglContext) {
    throw new RuntimeException("eglCreateContext,failed:" + GLUtils.getEGLErrorString(EGL14.eglGetError()));
  EGL14.eglQueryContext(wapper.eglDisplay, wapper.eglContext, EGL14.EGL_CONTEXT_CLIENT_VERSION, values, 0);
  wapper.eglSurface = EGL14.eglCreateWindowSurface(wapper.eglDisplay, wapper.eglConfig, mediaInputSurface, surfaceAttribs, 0);
  if (null == wapper.eglSurface || EGL14.EGL_NO_SURFACE == wapper.eglSurface) {
    throw new RuntimeException("eglCreateWindowSurface,failed:" + GLUtils.getEGLErrorString(EGL14.eglGetError()));

public void release() {
  if (EGL14.eglGetCurrentContext().equals(mEGLContext)) {
    EGL14.eglMakeCurrent(mEGLDisplay, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT);
  }
  EGL14.eglDestroySurface(mEGLDisplay, mEGLSurface);
  EGL14.eglDestroyContext(mEGLDisplay, mEGLContext);
  mSurface.release();
  mEGLDisplay = null;
  mEGLContext = null;
  mEGLSurface = null;
  mSurface = null;
}

public static void initOffScreenGL(OffScreenGLWapper wapper) {
  wapper.eglDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
  if (EGL14.EGL_NO_DISPLAY == wapper.eglDisplay) {
    throw new RuntimeException("eglGetDisplay,failed:" + GLUtils.getEGLErrorString(EGL14.eglGetError()));
  if (!EGL14.eglInitialize(wapper.eglDisplay, versions, 0, versions, 1)) {
    throw new RuntimeException("eglInitialize,failed:" + GLUtils.getEGLErrorString(EGL14.eglGetError()));
      EGL14.EGL_NONE
  };
  EGL14.eglChooseConfig(wapper.eglDisplay, configSpec, 0, configs, 0, 1, configsCount, 0);
  if (configsCount[0] <= 0) {
    throw new RuntimeException("eglChooseConfig,failed:" + GLUtils.getEGLErrorString(EGL14.eglGetError()));
      EGL14.EGL_NONE
  };
  wapper.eglContext = EGL14.eglCreateContext(wapper.eglDisplay, wapper.eglConfig, EGL14.EGL_NO_CONTEXT, contextSpec, 0);
  if (EGL14.EGL_NO_CONTEXT == wapper.eglContext) {
    throw new RuntimeException("eglCreateContext,failed:" + GLUtils.getEGLErrorString(EGL14.eglGetError()));
  EGL14.eglQueryContext(wapper.eglDisplay, wapper.eglContext, EGL14.EGL_CONTEXT_CLIENT_VERSION, values, 0);
  wapper.eglSurface = EGL14.eglCreatePbufferSurface(wapper.eglDisplay, wapper.eglConfig, surfaceAttribs, 0);
  if (null == wapper.eglSurface || EGL14.EGL_NO_SURFACE == wapper.eglSurface) {
    throw new RuntimeException("eglCreateWindowSurface,failed:" + GLUtils.getEGLErrorString(EGL14.eglGetError()));

private void init(EGLContext shared_context, final boolean with_depth_buffer, final boolean isRecordable) {
  if (DEBUG) Log.v(TAG, "init:");
  if (mEglDisplay != EGL14.EGL_NO_DISPLAY) {
    throw new RuntimeException("EGL already set up");
  }
  mEglDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
  if (mEglDisplay == EGL14.EGL_NO_DISPLAY) {
    throw new RuntimeException("eglGetDisplay failed");
  }
  final int[] version = new int[2];
  if (!EGL14.eglInitialize(mEglDisplay, version, 0, version, 1)) {
    mEglDisplay = null;
    throw new RuntimeException("eglInitialize failed");
  }
  shared_context = shared_context != null ? shared_context : EGL14.EGL_NO_CONTEXT;
  if (mEglContext == EGL14.EGL_NO_CONTEXT) {
    mEglConfig = getConfig(with_depth_buffer, isRecordable);
    if (mEglConfig == null) {
      throw new RuntimeException("chooseConfig failed");
    }
    // create EGL rendering context
    mEglContext = createContext(shared_context);
  }
  // confirm whether the EGL rendering context is successfully created
  final int[] values = new int[1];
  EGL14.eglQueryContext(mEglDisplay, mEglContext, EGL14.EGL_CONTEXT_CLIENT_VERSION, values, 0);
  if (DEBUG) Log.d(TAG, "EGLContext created, client version " + values[0]);
  makeDefault();    // makeCurrent(EGL14.EGL_NO_SURFACE);
}

  private int swap(final EGLSurface surface) {
//        if (DEBUG) Log.v(TAG, "swap:");
    if (!EGL14.eglSwapBuffers(mEglDisplay, surface)) {
      final int err = EGL14.eglGetError();
      if (DEBUG) Log.w(TAG, "swap:err=" + err);
      return err;
    }
    return EGL14.EGL_SUCCESS;
  }

private void makeDefault() {
  if (DEBUG) Log.v(TAG, "makeDefault:");
  if (!EGL14.eglMakeCurrent(mEglDisplay, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT)) {
    Log.w("TAG", "makeDefault" + EGL14.eglGetError());
  }
}

public void release() {
  if (DEBUG) Log.v(TAG, "release:");
  if (mEglDisplay != EGL14.EGL_NO_DISPLAY) {
    destroyContext();
    EGL14.eglTerminate(mEglDisplay);
    EGL14.eglReleaseThread();
  }
  mEglDisplay = EGL14.EGL_NO_DISPLAY;
  mEglContext = EGL14.EGL_NO_CONTEXT;
}

public EGLSurface createEGLWindowSurface(Object object){
  return EGL14.eglCreateWindowSurface(mEGLDisplay,mEGLConfig,object,new int[]{EGL14.EGL_NONE},0);
}

public boolean swapBuffers() {
  return EGL14.eglSwapBuffers(mEGLDisplay, mEGLSurface);
}

private static EGLDisplay getEglDisplay() {
 EGLDisplay eglDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
 if (eglDisplay == EGL14.EGL_NO_DISPLAY) {
  throw new RuntimeException(
    "Unable to get EGL14 display: 0x" + Integer.toHexString(EGL14.eglGetError()));
 }
 int[] version = new int[2];
 if (!EGL14.eglInitialize(eglDisplay, version, 0, version, 1)) {
  throw new RuntimeException(
    "Unable to initialize EGL14: 0x" + Integer.toHexString(EGL14.eglGetError()));
 }
 return eglDisplay;
}

public void render(Surface surface, int width, int height, Context context) {
  mEGLSurface = EGL14.eglCreateWindowSurface(mEGLDisplay, mEGLConfig, surface, EGL_SURFACE, 0);
  EGL14.eglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface, mEGLContext);
  mTextureRect = new TextureRect(context.getResources(), 2, 2);
  textureId = TextureHelper.loadTexture(context, R.drawable.lgq);
  GLES20.glClearColor(0.3f, 0.3f, 0.3f, 1.0f);
  GLES20.glEnable(GLES20.GL_DEPTH_TEST);
  GLES20.glEnable(GLES20.GL_CULL_FACE);
  MatrixState.setInitStack();
  GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
  GLES20.glViewport(0, 0, width, height);
  float ratio = width * 1.0f / height * 1.0f;
  MatrixState.setProjectFrustum(-ratio, ratio, -1f, 1f, 2f, 100f);
  MatrixState.setCamera(0f, 0f, 4f, 0f, 0f, 0f, 0f, 1f, 0f);
  mTextureRect.drawSelf(textureId);
  LogUtil.d("thread name is " + Thread.currentThread().getName());
  // 交换显存
  EGL14.eglSwapBuffers(mEGLDisplay, mEGLSurface);
}

private static EGLContext createEGLContext(
  EGLDisplay display, EGLConfig config, @SecureMode int secureMode) {
 int[] glAttributes;
 if (secureMode == SECURE_MODE_NONE) {
  glAttributes = new int[] {EGL14.EGL_CONTEXT_CLIENT_VERSION, 2, EGL14.EGL_NONE};
 } else {
  glAttributes =
    new int[] {
     EGL14.EGL_CONTEXT_CLIENT_VERSION,
     2,
     EGL_PROTECTED_CONTENT_EXT,
     EGL14.EGL_TRUE,
     EGL14.EGL_NONE
    };
 }
 EGLContext context =
   EGL14.eglCreateContext(
     display, config, android.opengl.EGL14.EGL_NO_CONTEXT, glAttributes, 0);
 if (context == null) {
  throw new GlException("eglCreateContext failed");
 }
 return context;
}

private void destroyWindowSurface(EGLSurface surface) {
  if (DEBUG) Log.v(TAG, "destroySurface:");
  if (surface != EGL14.EGL_NO_SURFACE) {
    EGL14.eglMakeCurrent(mEglDisplay,
      EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT);
    EGL14.eglDestroySurface(mEglDisplay, surface);
  }
  surface = EGL14.EGL_NO_SURFACE;
  if (DEBUG) Log.v(TAG, "destroySurface:finished");
}

@Override
public void release() {
 checkIsNotReleased();
 releaseSurface();
 detachCurrent();
 EGL14.eglDestroyContext(eglDisplay, eglContext);
 EGL14.eglReleaseThread();
 EGL14.eglTerminate(eglDisplay);
 eglContext = EGL14.EGL_NO_CONTEXT;
 eglDisplay = EGL14.EGL_NO_DISPLAY;
 eglConfig = null;
}

private void destroyContext() {
  if (DEBUG) Log.v(TAG, "destroyContext:");
  if (!EGL14.eglDestroyContext(mEglDisplay, mEglContext)) {
    Log.e("destroyContext", "display:" + mEglDisplay + " context: " + mEglContext);
    Log.e(TAG, "eglDestroyContex:" + EGL14.eglGetError());
  }
  mEglContext = EGL14.EGL_NO_CONTEXT;
  if (mDefaultContext != EGL14.EGL_NO_CONTEXT) {
    if (!EGL14.eglDestroyContext(mEglDisplay, mDefaultContext)) {
      Log.e("destroyContext", "display:" + mEglDisplay + " context: " + mDefaultContext);
      Log.e(TAG, "eglDestroyContex:" + EGL14.eglGetError());
    }
    mDefaultContext = EGL14.EGL_NO_CONTEXT;
  }
}

private static EGLConfig chooseEGLConfig(EGLDisplay display) {
 EGLConfig[] configs = new EGLConfig[1];
 int[] numConfigs = new int[1];
 boolean success =
   EGL14.eglChooseConfig(
     display,
     EGL_CONFIG_ATTRIBUTES,
     /* attrib_listOffset= */ 0,
     configs,
     /* configsOffset= */ 0,
     /* config_size= */ 1,
     numConfigs,
     /* num_configOffset= */ 0);
 if (!success || numConfigs[0] <= 0 || configs[0] == null) {
  throw new GlException(
    Util.formatInvariant(
      /* format= */ "eglChooseConfig failed: success=%b, numConfigs[0]=%d, configs[0]=%s",
      success, numConfigs[0], configs[0]));
 }
 return configs[0];
}

Most used methods

Popular in Java

Reading from database using SQL prepared statement
scheduleAtFixedRate (ScheduledExecutorService)
orElseThrow (Optional)
Return the contained value, if present, otherwise throw an exception to be created by the provided s
getExternalFilesDir (Context)
IOException (java.io)
Signals a general, I/O-related error. Error details may be specified when calling the constructor, a
URLConnection (java.net)
A connection to a URL for reading or writing. For HTTP connections, see HttpURLConnection for docume
Charset (java.nio.charset)
A charset is a named mapping between Unicode characters and byte sequences. Every Charset can decode
MessageDigest (java.security)
Uses a one-way hash function to turn an arbitrary number of bytes into a fixed-length byte sequence.
Format (java.text)
The base class for all formats. This is an abstract base class which specifies the protocol for clas
Modifier (javassist)
The Modifier class provides static methods and constants to decode class and member access modifiers
Top Vim plugins

How to useEGL14 in android.opengl

Best Java code snippets using android.opengl.EGL14 (Showing top 20 results out of 315)

How to use
EGL14
in
android.opengl