Ejemplo n.º 1
0
 public void SurfaceDestroyed(ISurfaceHolder surfaceHolder)
 {
     mLoop.Set(false);
     this.Interrupt();
     mSurfaceView.Holder.RemoveCallback(this);
     //MOVED SURFACE DESTROYING CODE TO FUNCTION CALLED WHEN APP IS PAUSED INSTEAD OF UNSTABLE CATCH UPON RETURN_______
     if (mEGLDisplay != null)
     {
         EGL14.EglMakeCurrent(mEGLDisplay, EGL14.EglNoSurface,
                 EGL14.EglNoSurface,
                 EGL14.EglNoContext);
         if (mEGLSurface != null)
         {
             EGL14.EglDestroySurface(mEGLDisplay, mEGLSurface);
         }
         if (mEGLSurfaceMedia != null)
         {
             EGL14.EglDestroySurface(mEGLDisplay, mEGLSurfaceMedia);
         }
         EGL14.EglDestroyContext(mEGLDisplay, mEGLContext);
         mSurfaceView.mHasGLContext.Set(false);
         EGL14.EglReleaseThread();
         EGL14.EglTerminate(mEGLDisplay);
         mSurfaceView.mSurface.Release();
     }
     //______________________________________________________________________________________________________________
 }
Ejemplo n.º 2
0
 /**
  * Makes our EGL context and surface current.
  */
 public void makeCurrent()
 {
     if (!EGL14.EglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface, mEGLContext))
     {
         throw new RuntimeException("eglMakeCurrent failed");
     }
 }
Ejemplo n.º 3
0
 public void DetachCurrent()
 {
     lock (EglBase.Lock)
     {
         if (!EGL14.EglMakeCurrent(_eglDisplay, EGL14.EglNoSurface, EGL14.EglNoSurface, EGL14.EglNoContext))
         {
             throw new RuntimeException("eglDetachCurrent failed: 0x" +
                                        Integer.ToHexString(EGL14.EglGetError()));
         }
     }
 }
Ejemplo n.º 4
0
        private bool ElgInitialize()
        {
            prevEglContext     = EGL14.EglGetCurrentContext();
            prevEglDisplay     = EGL14.EglGetCurrentDisplay();
            prevEglSurfaceRead = EGL14.EglGetCurrentSurface(EGL14.EglRead);
            prevEglSurfaceDraw = EGL14.EglGetCurrentSurface(EGL14.EglDraw);

            eglDisplay = EGL14.EglGetDisplay(EGL14.EglDefaultDisplay);
            if (eglDisplay == EGL14.EglNoDisplay)
            {
                return(false);
            }

            int[] version = new int[2];
            if (!EGL14.EglInitialize(eglDisplay, version, 0, version, 1))
            {
                return(false);
            }

            // Configure EGL for recording and OpenGL ES 2.0.
            int[] attribList =
            {
                EGL14.EglRedSize,                           8,
                EGL14.EglGreenSize,                         8,
                EGL14.EglBlueSize,                          8,
                EGL14.EglAlphaSize,                         8,
                EGL14.EglRenderableType, EGL14.EglOpenglEsBit,
                EGL_RECORDABLE_ANDROID,                     1,
                EGL14.EglNone
            };
            EGLConfig[] configs    = new EGLConfig[1];
            int[]       numConfigs = new int[1];
            EGL14.EglChooseConfig(eglDisplay, attribList, 0, configs, 0, configs.Length, numConfigs, 0);
            CheckEglError();

            // Configure context for OpenGL ES 2.0.
            int[] attrib_list =
            {
                EGL14.EglContextClientVersion, 1,
                EGL14.EglNone
            };
            eglContext = EGL14.EglCreateContext(eglDisplay, configs[0], EGL14.EglNoContext, attrib_list, 0);
            CheckEglError();

            int[] surfaceAttribs = { EGL14.EglNone };
            eglSurface = EGL14.EglCreateWindowSurface(eglDisplay, configs[0], surface, surfaceAttribs, 0);
            CheckEglError();

            EGL14.EglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext);
            CheckEglError();

            return(true);
        }
 /**
  * Discards all resources held by this class, notably the EGL context.  Also releases the
  * Surface that was passed to our constructor.
  */
 public void release()
 {
     if (mEGLDisplay != EGL14.EglNoDisplay)
     {
         EGL14.EglMakeCurrent(mEGLDisplay, EGL14.EglNoSurface, EGL14.EglNoSurface,
                              EGL14.EglNoContext);
         EGL14.EglDestroySurface(mEGLDisplay, mEGLSurface);
         EGL14.EglDestroyContext(mEGLDisplay, mEGLContext);
         EGL14.EglReleaseThread();
         EGL14.EglTerminate(mEGLDisplay);
     }
     mEGLDisplay = EGL14.EglNoDisplay;
     mEGLContext = EGL14.EglNoContext;
     mEGLSurface = EGL14.EglNoSurface;
     mSurface.Release();
 }
Ejemplo n.º 6
0
            public void MakeCurrent()
            {
                CheckIsNotReleased();
                if (_eglSurface == EGL14.EglNoSurface)
                {
                    throw new RuntimeException("No EGLSurface - can't make current");
                }

                lock (EglBase.Lock)
                {
                    if (!EGL14.EglMakeCurrent(_eglDisplay, _eglSurface, _eglSurface, _eglContext))
                    {
                        throw new RuntimeException("eglMakeCurrent failed: 0x" +
                                                   Integer.ToHexString(EGL14.EglGetError()));
                    }
                }
            }
Ejemplo n.º 7
0
        /**
         * Discard all resources held by this class, notably the EGL context. Also releases the
         * Surface that was passed to our constructor.
         */
        public void Release()
        {
            if (EGL14.EglGetCurrentContext().Equals(_EGLContext))
            {
                // Clear the current context and surface to ensure they are discarded immediately.
                EGL14.EglMakeCurrent(_EGLDisplay, EGL14.EglNoSurface, EGL14.EglNoSurface,
                                     EGL14.EglNoContext);
            }

            EGL14.EglDestroySurface(_EGLDisplay, _EGLSurface);
            EGL14.EglDestroyContext(_EGLDisplay, _EGLContext);

            //EGL14.eglTerminate(mEGLDisplay);
            _surface.Release();

            // null everything out so future attempts to use this object will cause an NPE
            _EGLDisplay = null;
            _EGLContext = null;
            _EGLSurface = null;
            _surface    = null;
        }
Ejemplo n.º 8
0
        public void ElgShutdown()
        {
            if (eglDisplay != EGL14.EglNoDisplay)
            {
                EGL14.EglMakeCurrent(eglDisplay, EGL14.EglNoSurface, EGL14.EglNoSurface, EGL14.EglNoContext);
                EGL14.EglDestroySurface(eglDisplay, eglSurface);
                EGL14.EglDestroyContext(eglDisplay, eglContext);
                EGL14.EglReleaseThread();
                EGL14.EglTerminate(eglDisplay);
            }

            surface.Release();

            eglDisplay = EGL14.EglNoDisplay;
            eglContext = EGL14.EglNoContext;
            eglSurface = EGL14.EglNoSurface;

            surface = null;

            EGL14.EglMakeCurrent(prevEglDisplay, prevEglSurfaceDraw, prevEglSurfaceRead, prevEglContext);
        }
Ejemplo n.º 9
0
 public override void Run()
 {
     if (mSurfaceView.mHasGLContext.Get())
     {
         return;
     }
     mEGLDisplay = EGL14.EglGetDisplay(EGL14.EglDefaultDisplay);
     int[] version = new int[2];
     EGL14.EglInitialize(mEGLDisplay, version, 0, version, 1);
     EGLConfig eglConfig = chooseEglConfig(mEGLDisplay);
     mEGLContext = EGL14
             .EglCreateContext(mEGLDisplay, eglConfig, EGL14.EglNoContext,
                     new int[] { EGL14.EglContextClientVersion, 2, EGL14.EglNone }, 0);
     int[] surfaceAttribs = {
                 EGL14.EglNone
         };
     mEGLSurface = EGL14
             .EglCreateWindowSurface(mEGLDisplay, eglConfig, mSurfaceView,
                     surfaceAttribs, 0);
     EGL14.EglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface, mEGLContext);
     // guarantee to only report surface as created once GL context
     // associated with the surface has been created, and call on the GL thread
     // NOT the main thread but BEFORE the codec surface is attached to the GL context
     RendererCallbacks result;
     if (mSurfaceView.mRendererCallbacksWeakReference != null && mSurfaceView.mRendererCallbacksWeakReference.TryGetTarget(out result))
     {
         result.onSurfaceCreated();
     }
     mSurfaceView.mMediaSurfaceCreated.Set(false);
     GLES20.GlClearColor(0.1f, 0.1f, 0.1f, 1.0f);
     mSurfaceView.mHasGLContext.Set(true);
     if (mSurfaceView.mRendererCallbacksWeakReference != null && mSurfaceView.mRendererCallbacksWeakReference.TryGetTarget(out result))
     {
         result.onContextCreated();
     }
     mLoop.Set(true);
     while (mLoop.Get())
     {
         if (!mSurfaceView.mPaused)
         {
             bool shouldRender = false;
             //we're just rendering when requested, so check that no one
             //has requested and if not, just continue
             if (mSurfaceView.mRenderMode.Get() == (int)Rendermode.WhenDirty)
             {
                 if (mSurfaceView.mRenderRequested.Get())
                 {
                     mSurfaceView.mRenderRequested.Set(false);
                     shouldRender = true;
                 }
             }
             else
             {
                 shouldRender = true;
             }
             if (mSurfaceView.mSizeChange.Get())
             {
                 GLES20.GlViewport(0, 0, mSurfaceView.mWidth, mSurfaceView.mHeight);
                 if (mSurfaceView.mRendererCallbacksWeakReference != null && mSurfaceView.mRendererCallbacksWeakReference.TryGetTarget(out result))
                 {
                     result.onSurfaceChanged(mSurfaceView.mWidth, mSurfaceView.mHeight);
                 }
                 mSurfaceView.mSizeChange.Set(false);
             }
             if (shouldRender)
             {
                 if (mSurfaceView.mRendererCallbacksWeakReference != null && mSurfaceView.mRendererCallbacksWeakReference.TryGetTarget(out result))
                 {
                     result.onPreDrawFrame();
                 }
                 if (mSurfaceView.mRendererCallbacksWeakReference != null && mSurfaceView.mRendererCallbacksWeakReference.TryGetTarget(out result))
                 {
                     result.onDrawScreen();
                 }
                 EGL14.EglSwapBuffers(mEGLDisplay, mEGLSurface);
                 if (mSurfaceView.mIsRecording.Get())
                 {
                     if (!mSurfaceView.mMediaSurfaceCreated.Get())
                     {
                         mEGLSurfaceMedia = EGL14
                             .EglCreateWindowSurface(mEGLDisplay, eglConfig, mSurfaceView.mSurface,
                                     surfaceAttribs, 0);
                         mSurfaceView.mMediaSurfaceCreated.Set(true);
                     }
                     EGL14.EglMakeCurrent(mEGLDisplay, mEGLSurfaceMedia, mEGLSurfaceMedia,
                             mEGLContext);
                     if (mSurfaceView.mRendererCallbacksWeakReference != null && mSurfaceView.mRendererCallbacksWeakReference.TryGetTarget(out result))
                     {
                         GLES20.GlViewport(0, 0, mSurfaceView.mOutWidth, mSurfaceView.mOutHeight);
                         //EGLExt.EglPresentationTimeANDROID(mEGLDisplay, mEGLSurfaceMedia, (JavaSystem.CurrentTimeMillis() - RecordableSurfaceView.mStartTimeMillisecs) * 1000L *1000L);
                         result.onDrawRecording();
                         GLES20.GlViewport(0, 0, mSurfaceView.mWidth, mSurfaceView.mHeight);
                     }
                     EGL14.EglSwapBuffers(mEGLDisplay, mEGLSurfaceMedia);
                     EGL14.EglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface,
                             mEGLContext);
                 }
             }
             while (mRunnableQueue.Count > 0)
             {
                 Runnable ev = mRunnableQueue.First.Value;
                 mRunnableQueue.RemoveFirst();
                 ev.Run();
             }
         }
         /*
         try
         {
             Thread.Sleep((long)(1f / 120.0f * 1000f));
         }
         catch (InterruptedException intex) // THIS IS KEY TO BLACKOUT BUG, THIS CATCH NEVER HAPPENS AND SO THE OLD SURFACE IS NEVER NUKED / REMADE mHasGLContext NEVER SET TO FALSE
         {
             if (mSurfaceView.mRendererCallbacksWeakReference != null && mSurfaceView.mRendererCallbacksWeakReference.TryGetTarget(out result))
             {
                 result.onSurfaceDestroyed();
             }
             if (mEGLDisplay != null)
             {
                 EGL14.EglMakeCurrent(mEGLDisplay, EGL14.EglNoSurface,
                         EGL14.EglNoSurface,
                         EGL14.EglNoContext);
                 if (mEGLSurface != null)
                 {
                     EGL14.EglDestroySurface(mEGLDisplay, mEGLSurface);
                 }
                 if (mEGLSurfaceMedia != null)
                 {
                     EGL14.EglDestroySurface(mEGLDisplay, mEGLSurfaceMedia);
                 }
                 EGL14.EglDestroyContext(mEGLDisplay, mEGLContext);
                 mSurfaceView.mHasGLContext.Set(false);
                 EGL14.EglReleaseThread();
                 EGL14.EglTerminate(mEGLDisplay);
                 mSurfaceView.mSurface.Release();
             }
             return;
         }*/
     }
 }