Android SurfaceViewRenderer: Allow to re-init after release() has been called

talk/app/webrtc/java/android/org/webrtc/SurfaceViewRenderer.java

 /*
  * libjingle
  * Copyright 2015 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 73 matching lines @@
   // Current size on screen in pixels. Updated in onLayout(), and should be consistent with
   // |widthSpec|/|heightSpec| after that.
   private int layoutWidth;
   private int layoutHeight;
   // Current surface size of the underlying Surface. Updated in surfaceChanged(), and should be
   // consistent with |layoutWidth|/|layoutHeight| after that.
   // TODO(magjed): Enable hardware scaler with SurfaceHolder.setFixedSize(). This will decouple
   // layout and surface size.
   private int surfaceWidth;
   private int surfaceHeight;
+  // |isSurfaceCreated| keeps track of the current status in surfaceCreated()/surfaceDestroyed().
+  private boolean isSurfaceCreated;
   // Last rendered frame dimensions, or 0 if no frame has been rendered yet.
   private int frameWidth;
   private int frameHeight;
   private int frameRotation;
   // |scalingType| determines how the video will fill the allowed layout area in onMeasure().
   private RendererCommon.ScalingType scalingType = RendererCommon.ScalingType.SCALE_ASPECT_BALANCED;
   // If true, mirrors the video stream horizontally.
   private boolean mirror;
   // Callback for reporting renderer events.
   private RendererCommon.RendererEvents rendererEvents;
@@ skipping 17 matching lines @@
     @Override public void run() {
       renderFrameOnRenderThread();
     }
   };
 
   /**
    * Standard View constructor. In order to render something, you must first call init().
    */
   public SurfaceViewRenderer(Context context) {
     super(context);
+    getHolder().addCallback(this);
   }
 
   /**
    * Standard View constructor. In order to render something, you must first call init().
    */
   public SurfaceViewRenderer(Context context, AttributeSet attrs) {
     super(context, attrs);
-  }
-
-  /**
-   * Initialize this class, sharing resources with |sharedContext|.
-   */
-  public void init(
-      EGLContext sharedContext, RendererCommon.RendererEvents rendererEvents) {
-    if (renderThreadHandler != null) {
-      throw new IllegalStateException("Already initialized");
-    }
-    Logging.d(TAG, "Initializing");
-    this.rendererEvents = rendererEvents;
-    renderThread = new HandlerThread(TAG);
-    renderThread.start();
-    renderThreadHandler = new Handler(renderThread.getLooper());
-    eglBase = new EglBase(sharedContext, EglBase.ConfigType.PLAIN);
-    drawer = new GlRectDrawer();
     getHolder().addCallback(this);
   }
 
   /**
+   * Initialize this class, sharing resources with |sharedContext|. It is allowed to call init() to
+   * reinitialize the renderer after a previous init()/release() cycle.
+   */
+  public void init(
+      EGLContext sharedContext, RendererCommon.RendererEvents rendererEvents) {
+    synchronized (handlerLock) {
+      if (renderThreadHandler != null) {
+        throw new IllegalStateException("Already initialized");
+      }
+      Logging.d(TAG, "Initializing");
+      this.rendererEvents = rendererEvents;
+      renderThread = new HandlerThread(TAG);
+      renderThread.start();
+      drawer = new GlRectDrawer();
+      eglBase = new EglBase(sharedContext, EglBase.ConfigType.PLAIN);
+      renderThreadHandler = new Handler(renderThread.getLooper());
+    }
+    tryCreateEglSurface();
+  }
+
+  /**
+   * Create and make an EGLSurface current if both init() and surfaceCreated() have been called.
+   */
+  public void tryCreateEglSurface() {
+    // |renderThreadHandler| is only created after |eglBase| is created in init(), so the
+    // following code will only execute if eglBase != null.
+    runOnRenderThread(new Runnable() {
+      @Override public void run() {
+        synchronized (layoutLock) {
+          if (isSurfaceCreated) {
+            eglBase.createSurface(getHolder().getSurface());
+            eglBase.makeCurrent();
+            // Necessary for YUV frames with odd width.
+            GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 1);
+          }
+        }
+      }
+    });
+  }
+
+  /**
    * Block until any pending frame is returned and all GL resources released, even if an interrupt
    * occurs. If an interrupt occurs during release(), the interrupt flag will be set. This function
    * should be called before the Activity is destroyed and the EGLContext is still valid. If you
    * don't call this function, the GL resources might leak.
    */
   public void release() {
     synchronized (handlerLock) {
       if (renderThreadHandler == null) {
         Logging.d(TAG, "Already released");
         return;
       }
       // Release EGL and GL resources on render thread.
       // TODO(magjed): This might not be necessary - all OpenGL resources are automatically deleted
       // when the EGL context is lost. It might be dangerous to delete them manually in
       // Activity.onDestroy().
       renderThreadHandler.postAtFrontOfQueue(new Runnable() {
         @Override public void run() {
           drawer.release();
           drawer = null;
           if (yuvTextures != null) {
             GLES20.glDeleteTextures(3, yuvTextures, 0);
             yuvTextures = null;
           }
+          // Clear last rendered image to black.
+          GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
+          eglBase.swapBuffers();
           eglBase.release();
           eglBase = null;
         }
       });
       // Don't accept any more frames or messages to the render thread.
       renderThreadHandler = null;
     }
     // Quit safely to make sure the EGL/GL cleanup posted above is executed.
     renderThread.quitSafely();
     synchronized (frameLock) {
       if (pendingFrame != null) {
         VideoRenderer.renderFrameDone(pendingFrame);
         pendingFrame = null;
       }
     }
     // The |renderThread| cleanup is not safe to cancel and we need to wait until it's done.
     ThreadUtils.joinUninterruptibly(renderThread);
     renderThread = null;
+    // Reset statistics and event reporting.
+    synchronized (layoutLock) {
+      frameWidth = 0;
+      frameHeight = 0;
+      frameRotation = 0;
+      rendererEvents = null;
+    }
+    synchronized (statisticsLock) {
+      framesReceived = 0;
+      framesDropped = 0;
+      framesRendered = 0;
+      firstFrameTimeNs = 0;
+      renderTimeNs = 0;
+    }
   }
 
   /**
    * Set if the video stream should be mirrored or not.
    */
   public void setMirror(final boolean mirror) {
     synchronized (layoutLock) {
       this.mirror = mirror;
     }
   }
@@ skipping 69 matching lines @@
       layoutHeight = bottom - top;
     }
     // Might have a pending frame waiting for a layout of correct size.
     runOnRenderThread(renderFrameRunnable);
   }
 
   // SurfaceHolder.Callback interface.
   @Override
   public void surfaceCreated(final SurfaceHolder holder) {
     Logging.d(TAG, "Surface created");
-    runOnRenderThread(new Runnable() {
-      @Override public void run() {
-        eglBase.createSurface(holder.getSurface());
-        eglBase.makeCurrent();
-        // Necessary for YUV frames with odd width.
-        GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 1);
-      }
-    });
+    synchronized (layoutLock) {
+      isSurfaceCreated = true;
+    }
+    tryCreateEglSurface();
   }
 
   @Override
   public void surfaceDestroyed(SurfaceHolder holder) {
     Logging.d(TAG, "Surface destroyed");
     synchronized (layoutLock) {
+      isSurfaceCreated = false;
       surfaceWidth = 0;
       surfaceHeight = 0;
     }
     runOnRenderThread(new Runnable() {
       @Override public void run() {
         eglBase.releaseSurface();
       }
     });
   }
 
@@ skipping 72 matching lines @@
         return;
       }
       frame = pendingFrame;
       pendingFrame = null;
     }
 
     final long startTimeNs = System.nanoTime();
     final float[] texMatrix;
     synchronized (layoutLock) {
       final float[] rotatedSamplingMatrix =
           RendererCommon.rotateTextureMatrix(frame.samplingMatrix, frame.rotationDegree);

[hbos, 2015/10/08 11:19:35]

Is this diff here a merge diff or cleanup? Woah only shows up in diff-with-ps-1
not "show" what is this sorcery.

[magjed_webrtc, 2015/10/08 12:44:43]

You see unrelated rebase stuff when you diff patches for some reason.

       final float[] layoutMatrix = RendererCommon.getLayoutMatrix(
           mirror, frameAspectRatio(), (float) layoutWidth / layoutHeight);
       texMatrix = RendererCommon.multiplyMatrices(rotatedSamplingMatrix, layoutMatrix);
     }
 
     GLES20.glViewport(0, 0, surfaceWidth, surfaceHeight);
     if (frame.yuvFrame) {
       // Make sure YUV textures are allocated.
       if (yuvTextures == null) {
         yuvTextures = new int[3];
@@ skipping 62 matching lines @@
       if (framesReceived > 0 && framesRendered > 0) {
         final long timeSinceFirstFrameNs = System.nanoTime() - firstFrameTimeNs;
         Logging.d(TAG, "Duration: " + (int) (timeSinceFirstFrameNs / 1e6) +
             " ms. FPS: " + (float) framesRendered * 1e9 / timeSinceFirstFrameNs);
         Logging.d(TAG, "Average render time: "
             + (int) (renderTimeNs / (1000 * framesRendered)) + " us.");
       }
     }
   }
 }