Add option to print peer connection factory Java stack traces.

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

 /*
  * libjingle
  * Copyright 2014 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 18 matching lines @@
 
 import java.util.ArrayList;
 import java.util.concurrent.CountDownLatch;
 
 import javax.microedition.khronos.egl.EGLConfig;
 import javax.microedition.khronos.opengles.GL10;
 
 import android.annotation.SuppressLint;
 import android.graphics.Point;
 import android.graphics.Rect;
-import android.graphics.SurfaceTexture;
 import android.opengl.EGL14;
 import android.opengl.EGLContext;
 import android.opengl.GLES20;
 import android.opengl.GLSurfaceView;
-import android.opengl.Matrix;
 
 import org.webrtc.Logging;
 import org.webrtc.VideoRenderer.I420Frame;
 
 /**
  * Efficiently renders YUV frames using the GPU for CSC.
  * Clients will want first to call setView() to pass GLSurfaceView
  * and then for each video stream either create instance of VideoRenderer using
  * createGui() call or VideoRenderer.Callbacks interface using create() call.
  * Only one instance of the class can be created.
@@ skipping 15 matching lines @@
   private int screenHeight;
   // List of yuv renderers.
   private final ArrayList<YuvImageRenderer> yuvImageRenderers;
   // |drawer| is synchronized on |yuvImageRenderers|.
   private GlRectDrawer drawer;
   private static final int EGL14_SDK_VERSION =
       android.os.Build.VERSION_CODES.JELLY_BEAN_MR1;
   // Current SDK version.
   private static final int CURRENT_SDK_VERSION =
       android.os.Build.VERSION.SDK_INT;
+  // Render and draw threads.
+  private static Thread renderFrameThread;
+  private static Thread drawThread;
 
   private VideoRendererGui(GLSurfaceView surface) {
     this.surface = surface;
     // Create an OpenGL ES 2.0 context.
     surface.setPreserveEGLContextOnPause(true);
     surface.setEGLContextClientVersion(2);
     surface.setRenderer(this);
     surface.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
 
     yuvImageRenderers = new ArrayList<YuvImageRenderer>();
@@ skipping 275 matching lines @@
       }
     }
 
     @Override
     public synchronized void renderFrame(I420Frame frame) {
       if (surface == null) {
         // This object has been released.
         VideoRenderer.renderFrameDone(frame);
         return;
       }
+      if (renderFrameThread == null) {
+        renderFrameThread = Thread.currentThread();
+      }
       if (!seenFrame && rendererEvents != null) {
         Logging.d(TAG, "ID: " + id + ". Reporting first rendered frame.");
         rendererEvents.onFirstFrameRendered();
       }
       framesReceived++;
       synchronized (pendingFrameLock) {
         // Check input frame parameters.
         if (frame.yuvFrame) {
           if (frame.yuvStrides[0] < frame.width ||
               frame.yuvStrides[1] < frame.width / 2 ||
               frame.yuvStrides[2] < frame.width / 2) {
             Logging.e(TAG, "Incorrect strides " + frame.yuvStrides[0] + ", " +
                 frame.yuvStrides[1] + ", " + frame.yuvStrides[2]);
             VideoRenderer.renderFrameDone(frame);
             return;
           }
         }
 
         if (pendingFrame != null) {
           // Skip rendering of this frame if previous frame was not rendered yet.
           framesDropped++;
           VideoRenderer.renderFrameDone(frame);
+          seenFrame = true;
           return;
         }
         pendingFrame = frame;
       }
       setSize(frame.width, frame.height, frame.rotationDegree);
       seenFrame = true;
 
       // Request rendering.
       surface.requestRender();
     }
@@ skipping 16 matching lines @@
     if (instance == null){
       return;
     }
     Logging.d(TAG, "VideoRendererGui.dispose");
     synchronized (instance.yuvImageRenderers) {
       for (YuvImageRenderer yuvImageRenderer : instance.yuvImageRenderers) {
         yuvImageRenderer.release();
       }
       instance.yuvImageRenderers.clear();
     }
+    renderFrameThread = null;
+    drawThread = null;
     instance.surface = null;
     eglContext = null;
     eglContextReady = null;
     instance = null;
   }
 
   /**
    * Creates VideoRenderer with top left corner at (x, y) and resolution
    * (width, height). All parameters are in percentage of screen resolution.
    */
@@ skipping 115 matching lines @@
     }
     synchronized (instance.yuvImageRenderers) {
       for (YuvImageRenderer yuvImageRenderer : instance.yuvImageRenderers) {
         if (yuvImageRenderer == renderer) {
           yuvImageRenderer.reset();
         }
       }
     }
   }
 
+  private static void printStackTrace(Thread thread, String threadName) {

[wzh, 2015/10/12 20:45:47]

nit: if we can have a global util func for this, we don't need to duplicate the
same logic over again.

+    if (thread != null) {
+      StackTraceElement[] stackTraces = thread.getStackTrace();
+      if (stackTraces.length > 0) {
+        Logging.d(TAG, threadName + " stacks trace:");
+        for (StackTraceElement stackTrace : stackTraces) {
+          Logging.d(TAG, stackTrace.toString());
+        }
+      }
+    }
+  }
+
+  public static synchronized void printStackTraces() {
+    if (instance == null) {
+      return;
+    }
+    printStackTrace(renderFrameThread, "Render frame thread");
+    printStackTrace(drawThread, "Draw thread");
+  }
+
   @SuppressLint("NewApi")
   @Override
   public void onSurfaceCreated(GL10 unused, EGLConfig config) {
     Logging.d(TAG, "VideoRendererGui.onSurfaceCreated");
     // Store render EGL context.
     if (CURRENT_SDK_VERSION >= EGL14_SDK_VERSION) {
       synchronized (VideoRendererGui.class) {
         eglContext = EGL14.eglGetCurrentContext();
         Logging.d(TAG, "VideoRendererGui EGL Context: " + eglContext);
       }
@@ skipping 28 matching lines @@
     screenHeight = height;
     synchronized (yuvImageRenderers) {
       for (YuvImageRenderer yuvImageRenderer : yuvImageRenderers) {
         yuvImageRenderer.setScreenSize(screenWidth, screenHeight);
       }
     }
   }
 
   @Override
   public void onDrawFrame(GL10 unused) {
+    if (drawThread == null) {
+      drawThread = Thread.currentThread();
+    }
     GLES20.glViewport(0, 0, screenWidth, screenHeight);
     GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
     synchronized (yuvImageRenderers) {
       for (YuvImageRenderer yuvImageRenderer : yuvImageRenderers) {
         yuvImageRenderer.draw(drawer);
       }
     }
   }
 
 }