Java EGLContext类代码示例

import android.opengl.EGLContext; //导入依赖的package包/类
public EGLSurface createGLESWithPBuffer(EGLConfigAttrs attrs,EGLContextAttrs ctxAttrs,int width,int height){
    EGLConfig config=getConfig(attrs.surfaceType(EGL14.EGL_PBUFFER_BIT));
    if(config==null){
        log("getConfig failed : "+EGL14.eglGetError());
        return null;
    }
    EGLContext eglContext=createContext(config,EGL14.EGL_NO_CONTEXT,ctxAttrs);
    if(eglContext==EGL14.EGL_NO_CONTEXT){
        log("createContext failed : "+EGL14.eglGetError());
        return null;
    }
    EGLSurface eglSurface=createPBufferSurface(config,width,height);
    if(eglSurface==EGL14.EGL_NO_SURFACE){
        log("createWindowSurface failed : "+EGL14.eglGetError());
        return null;
    }
    if(!EGL14.eglMakeCurrent(mEGLDisplay,eglSurface,eglSurface,eglContext)){
        log("eglMakeCurrent failed : "+EGL14.eglGetError());
        return null;
    }
    return eglSurface;
}
 

import android.opengl.EGLContext; //导入依赖的package包/类
public final void setEglContext(final EGLContext shared_context, final int tex_id, final Object surface, final boolean isRecordable) {
	if (DEBUG) Log.i(TAG, "setEglContext:");
	if (!(surface instanceof Surface) && !(surface instanceof SurfaceTexture) && !(surface instanceof SurfaceHolder))
		throw new RuntimeException("unsupported window type:" + surface);
	synchronized (mSync) {
		if (mRequestRelease) return;
		mShard_context = shared_context;
		mTexId = tex_id;
		mSurface = surface;
		mIsRecordable = isRecordable;
		mRequestSetEglContext = true;
		mSync.notifyAll();
		try {
			mSync.wait();
		} catch (final InterruptedException e) {
		}
	}
}
 

import android.opengl.EGLContext; //导入依赖的package包/类
/**
 * Tears down the EGL surface and context we've been using to feed the MediaCodec input
 * surface, and replaces it with a new one that shares with the new context.
 * <p>
 * This is useful if the old context we were sharing with went away (maybe a GLSurfaceView
 * that got torn down) and we need to hook up with the new one.
 */
private void handleUpdateSharedContext(EGLContext newSharedContext) {
    Log.d(TAG, "handleUpdatedSharedContext " + newSharedContext);

    // Release the EGLSurface and EGLContext.
    mInputWindowSurface.releaseEglSurface();
    eglDrawer.deInit();

    mEglCore.release();

    // Create a new EGLContext and recreate the window surface.
    mEglCore = new EglCore(newSharedContext, EglCore.FLAG_RECORDABLE);
    mInputWindowSurface.recreate(mEglCore);
    mInputWindowSurface.makeCurrent();

    eglDrawer.init();
    eglDrawer.setViewportSize(encoderConfig.mWidth,encoderConfig.mHeight);
}
 

import android.opengl.EGLContext; //导入依赖的package包/类
private void prepareEncoder(EGLContext sharedContext, int width, int height, int bitRate,
        File outputFile) {
    try {
        MMediaMuxer =new MMediaMuxer(outputFile);
        mVideoEncoder = new VideoEncoderCore(width, height, bitRate, MMediaMuxer);
       // mAudioEncoder = new AudioEncoderCore(MMediaMuxer);
    } catch (IOException ioe) {
        throw new RuntimeException(ioe);
    }
    mEglCore = new EglCore(sharedContext, EglCore.FLAG_RECORDABLE);
    mInputWindowSurface = new WindowSurface(mEglCore, mVideoEncoder.getInputSurface(), true);
    mInputWindowSurface.makeCurrent();

    eglDrawer.init();
    eglDrawer.setViewportSize(encoderConfig.mWidth,encoderConfig.mHeight);
}
 

import android.opengl.EGLContext; //导入依赖的package包/类
/**
 * Test for {@link GLTools#setPresentationTime(EGLDisplay, EGLSurface, long)} .
 * @throws Exception by some fails
 */
@Test
public final void testSetPresentationTime() throws Exception {
    final EGLDisplay eglDisplay = GLTools.newDisplay();
    final EGLConfig eglConfig = GLTools.newConfig(eglDisplay, true);
    final EGLContext eglContext = GLTools.newContext(eglDisplay, eglConfig);
    final EGLSurface eglSurface =
            GLTools.newSurface(eglDisplay, eglConfig, FRAME_SIZE, FRAME_SIZE);
    GLTools.makeCurrent(eglDisplay, eglSurface, eglContext);

    final int txt = GLTools.newTexture(TEXTURE_LEVEL);
    final SurfaceTexture surfaceTexture = new SurfaceTexture(txt, true);
    final Surface surface = new Surface(surfaceTexture);
    final EGLSurface window = GLTools.newSurface(eglDisplay, eglConfig, surface);

    GLTools.setPresentationTime(eglDisplay, window, PRESENTATION_TIME);

    GLTools.closeSurface(eglDisplay, window);
    surface.release();
    surfaceTexture.release();
    GLTools.closeTexture(txt, TEXTURE_LEVEL);

    GLTools.closeSurface(eglDisplay, eglSurface);
    GLTools.closeContext(eglDisplay, eglContext);
    GLTools.closeDisplay(eglDisplay);
}
 

import android.opengl.EGLContext; //导入依赖的package包/类
/**
 * Test for {@link GLTools#newTexture(int)} and {@link GLTools#closeTexture(int, int)}.
 * @throws Exception by some fails
 */
@Test
public final void testTexture() throws Exception {
    final EGLDisplay eglDisplay = GLTools.newDisplay();
    final EGLConfig eglConfig = GLTools.newConfig(eglDisplay, true);
    final EGLContext eglContext = GLTools.newContext(eglDisplay, eglConfig);
    final EGLSurface eglSurface =
            GLTools.newSurface(eglDisplay, eglConfig, FRAME_SIZE, FRAME_SIZE);

    GLTools.makeCurrent(eglDisplay, eglSurface, eglContext);

    GLTools.closeTexture(GLTools.newTexture(TEXTURE_LEVEL), TEXTURE_LEVEL);

    GLTools.closeSurface(eglDisplay, eglSurface);
    GLTools.closeContext(eglDisplay, eglContext);
    GLTools.closeDisplay(eglDisplay);
}
 

import android.opengl.EGLContext; //导入依赖的package包/类
/**
 * Test for {@link GLTools#newShader(int[])} and {@link GLTools#closeShader(int[])}.
 * @throws Exception by some fails
 */
@Test
public final void testShader() throws Exception {
    final EGLDisplay eglDisplay = GLTools.newDisplay();
    final EGLConfig eglConfig = GLTools.newConfig(eglDisplay, true);
    final EGLContext eglContext = GLTools.newContext(eglDisplay, eglConfig);
    final EGLSurface eglSurface =
            GLTools.newSurface(eglDisplay, eglConfig, FRAME_SIZE, FRAME_SIZE);

    GLTools.makeCurrent(eglDisplay, eglSurface, eglContext);

    final int[] attrs = new int[5];
    GLTools.newShader(attrs);
    GLTools.closeShader(attrs);

    GLTools.closeSurface(eglDisplay, eglSurface);
    GLTools.closeContext(eglDisplay, eglContext);
    GLTools.closeDisplay(eglDisplay);
}
 

import android.opengl.EGLContext; //导入依赖的package包/类
private static EGLContext createEglContext(
    EglBase14.Context sharedContext, EGLDisplay eglDisplay, EGLConfig eglConfig) {
  if (sharedContext != null && sharedContext.egl14Context == EGL14.EGL_NO_CONTEXT) {
    throw new RuntimeException("Invalid sharedContext");
  }
  int[] contextAttributes = {EGL14.EGL_CONTEXT_CLIENT_VERSION, 2, EGL14.EGL_NONE};
  EGLContext rootContext =
      sharedContext == null ? EGL14.EGL_NO_CONTEXT : sharedContext.egl14Context;
  final EGLContext eglContext;
  synchronized (EglBase.lock) {
    eglContext = EGL14.eglCreateContext(eglDisplay, eglConfig, rootContext, contextAttributes, 0);
  }
  if (eglContext == EGL14.EGL_NO_CONTEXT) {
    throw new RuntimeException(
        "Failed to create EGL context: 0x" + Integer.toHexString(EGL14.eglGetError()));
  }
  return eglContext;
}
 

import android.opengl.EGLContext; //导入依赖的package包/类
/**
 * Tears down the EGL surface and context we've been using to feed the MediaCodec input
 * surface, and replaces it with a new one that shares with the new context.
 * <p>
 * This is useful if the old context we were sharing with went away (maybe a GLSurfaceView
 * that got torn down) and we need to hook up with the new one.
 */
private void handleUpdateSharedContext(EGLContext newSharedContext) {
    Log.d(TAG, "handleUpdatedSharedContext " + newSharedContext);

    // Release the EGLSurface and EGLContext.
    mInputWindowSurface.releaseEglSurface();
    mFullScreen.release(false);
    mEglCore.release();

    // Create a new EGLContext and recreate the window surface.
    mEglCore = new EglCore(newSharedContext, EglCore.FLAG_RECORDABLE);
    mInputWindowSurface.recreate(mEglCore);
    mInputWindowSurface.makeCurrent();

    // Create new programs and such for the new context.
    mFullScreen = new FullFrameRect(FilterManager.getCameraFilter(mCurrentFilterType, mContext));
}
 

import android.opengl.EGLContext; //导入依赖的package包/类
public final void setEglContext(final EGLContext shared_context, final int tex_id, final Object surface, final boolean isRecordable) {
	if (DEBUG) Log.i(TAG, "setEglContext:");
	if (!(surface instanceof Surface) && !(surface instanceof SurfaceTexture) && !(surface instanceof SurfaceHolder))
		throw new RuntimeException("unsupported window type:" + surface);
	synchronized (mSync) {
		if (mRequestRelease) return;
		mShard_context = shared_context;
		mTexId = tex_id;
		mSurface = surface;
		mIsRecordable = isRecordable;
		mRequestSetEglContext = true;
		Matrix.setIdentityM(mMatrix, 0);
		Matrix.setIdentityM(mMatrix, 16);
		mSync.notifyAll();
		try {
			mSync.wait();
		} catch (final InterruptedException e) {
		}
	}
}
 

import android.opengl.EGLContext; //导入依赖的package包/类
/**
 * Tears down the EGL surface and context we've been using to feed the MediaCodec input
 * surface, and replaces it with a new one that shares with the new context.
 * <p>
 * This is useful if the old context we were sharing with went away (maybe a GLSurfaceView
 * that got torn down) and we need to hook up with the new one.
 */
private void handleUpdateSharedContext(EGLContext newSharedContext) {
    Log.d(TAG, "handleUpdatedSharedContext " + newSharedContext);

    // Release the EGLSurface and EGLContext.
    mInputWindowSurface.releaseEglSurface();
    mInput.destroy();
    mEglCore.release();

    // Create a new EGLContext and recreate the window surface.
    mEglCore = new EglCore(newSharedContext, EglCore.FLAG_RECORDABLE);
    mInputWindowSurface.recreate(mEglCore);
    mInputWindowSurface.makeCurrent();

    // Create new programs and such for the new context.
    mInput = new MagicCameraInputFilter();
    mInput.init();
    filter = MagicFilterFactory.initFilters(type);
    if(filter != null){
        filter.init();
        filter.onInputSizeChanged(mPreviewWidth, mPreviewHeight);
        filter.onDisplaySizeChanged(mVideoWidth, mVideoHeight);
    }
}
 

import android.opengl.EGLContext; //导入依赖的package包/类
private void prepareEncoder(EGLContext sharedContext, int width, int height, int bitRate,
        File outputFile) {
    try {
        mVideoEncoder = new VideoEncoderCore(width, height, bitRate, outputFile);
    } catch (IOException ioe) {
        throw new RuntimeException(ioe);
    }
    mVideoWidth = width;
    mVideoHeight = height;
    mEglCore = new EglCore(sharedContext, EglCore.FLAG_RECORDABLE);
    mInputWindowSurface = new WindowSurface(mEglCore, mVideoEncoder.getInputSurface(), true);
    mInputWindowSurface.makeCurrent();

    mInput = new MagicCameraInputFilter();
    mInput.init();
    filter = MagicFilterFactory.initFilters(type);
    if(filter != null){
        filter.init();
        filter.onInputSizeChanged(mPreviewWidth, mPreviewHeight);
        filter.onDisplaySizeChanged(mVideoWidth, mVideoHeight);
    }
}
 

import android.opengl.EGLContext; //导入依赖的package包/类
public WebRtcClient(RtcListener listener, String host, PeerConnectionParameters params, EGLContext mEGLcontext) {
    mListener = listener;
    pcParams = params;
    // initializeAndroidGlobals的第一个参数需要是activity或者application
    PeerConnectionFactory.initializeAndroidGlobals(App.getInstance(), true, true,
            params.videoCodecHwAcceleration, mEGLcontext);
    factory = new PeerConnectionFactory();
    MessageHandler messageHandler = new MessageHandler();

    try {
        client = IO.socket(host);
    } catch (URISyntaxException e) {
        e.printStackTrace();
    }
    client.on("id", messageHandler.onId);
    client.on("message", messageHandler.onMessage);
    client.connect(); // connect后，服务端会emit一个id信息，返回该客户端的id

    iceServers.add(new PeerConnection.IceServer("stun:23.21.150.121"));
    iceServers.add(new PeerConnection.IceServer("stun:stun.l.google.com:19302"));

    pcConstraints.mandatory.add(new MediaConstraints.KeyValuePair("OfferToReceiveAudio", "true"));
    pcConstraints.mandatory.add(new MediaConstraints.KeyValuePair("OfferToReceiveVideo", "true"));
    pcConstraints.optional.add(new MediaConstraints.KeyValuePair("DtlsSrtpKeyAgreement", "true"));
}
 

import android.opengl.EGLContext; //导入依赖的package包/类
public final void setEglContext(EGLContext shared_context, int tex_id, Object surface, boolean isRecordable) {
	if (DEBUG) Log.i(TAG, "setEglContext:");
	if (!(surface instanceof Surface) && !(surface instanceof SurfaceTexture) && !(surface instanceof SurfaceHolder))
		throw new RuntimeException("unsupported window type:" + surface);
	synchronized (mSync) {
		if (mRequestRelease) return;
		mShard_context = shared_context;
		mTexId = tex_id;
		mSurface = surface;
		mIsRecordable = isRecordable;
		mRequestSetEglContext = true;
		mSync.notifyAll();
		try {
			mSync.wait();
		} catch (InterruptedException e) {
		}
	}
}
 

import android.opengl.EGLContext; //导入依赖的package包/类
/**
 * Tears down the EGL surface and context we've been using to feed the MediaCodec input
 * surface, and replaces it with a new one that shares with the new context.
 * <p>
 * This is useful if the old context we were sharing with went away (maybe a GLSurfaceView
 * that got torn down) and we need to hook up with the new one.
 */
private void handleUpdateSharedContext(EGLContext newSharedContext) {
    Log.d(TAG, "handleUpdatedSharedContext " + newSharedContext);

    // Release the EGLSurface and EGLContext.
    mInputWindowSurface.releaseEglSurface();
    mFullScreen.release(false);
    mEglCore.release();

    // Create a new EGLContext and recreate the window surface.
    mEglCore = new EglCore(newSharedContext, EglCore.FLAG_RECORDABLE);
    mInputWindowSurface.recreate(mEglCore);
    mInputWindowSurface.makeCurrent();

    // Create new programs and such for the new context.
    mFullScreen = new FullFrameRect(
            new Texture2dProgram(Texture2dProgram.ProgramType.TEXTURE_EXT));
}