Log to webrtc logging stream from java code.

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 26 matching lines @@
 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 android.util.Log;
 
+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.
  */
 public class VideoRendererGui implements GLSurfaceView.Renderer {
@@ skipping 94 matching lines @@
     private int videoHeight;
 
     // This is the degree that the frame should be rotated clockwisely to have
     // it rendered up right.
     private int rotationDegree;
 
     private YuvImageRenderer(
         GLSurfaceView surface, int id,
         int x, int y, int width, int height,
         RendererCommon.ScalingType scalingType, boolean mirror) {
-      Log.d(TAG, "YuvImageRenderer.Create id: " + id);
+      Logging.d(TAG, "YuvImageRenderer.Create id: " + id);
       this.surface = surface;
       this.id = id;
       this.scalingType = scalingType;
       this.mirror = mirror;
       layoutInPercentage = new Rect(x, y, Math.min(100, x + width), Math.min(100, y + height));
       updateLayoutProperties = false;
       rotationDegree = 0;
     }
 
     private synchronized void release() {
       surface = null;
       synchronized (pendingFrameLock) {
         if (pendingFrame != null) {
           VideoRenderer.renderFrameDone(pendingFrame);
           pendingFrame = null;
         }
       }
     }
 
     private void createTextures() {
-      Log.d(TAG, "  YuvImageRenderer.createTextures " + id + " on GL thread:" +
+      Logging.d(TAG, "  YuvImageRenderer.createTextures " + id + " on GL thread:" +
           Thread.currentThread().getId());
 
       // Generate 3 texture ids for Y/U/V and place them into |yuvTextures|.
       for (int i = 0; i < 3; i++)  {
         yuvTextures[i] = GlUtil.generateTexture(GLES20.GL_TEXTURE_2D);
       }
     }
 
     private void updateLayoutMatrix() {
       synchronized(updateLayoutLock) {
         if (!updateLayoutProperties) {
           return;
         }
         // Initialize to maximum allowed area. Round to integer coordinates inwards the layout
         // bounding box (ceil left/top and floor right/bottom) to not break constraints.
         displayLayout.set(
             (screenWidth * layoutInPercentage.left + 99) / 100,
             (screenHeight * layoutInPercentage.top + 99) / 100,
             (screenWidth * layoutInPercentage.right) / 100,
             (screenHeight * layoutInPercentage.bottom) / 100);
-        Log.d(TAG, "ID: "  + id + ". AdjustTextureCoords. Allowed display size: "
+        Logging.d(TAG, "ID: "  + id + ". AdjustTextureCoords. Allowed display size: "
             + displayLayout.width() + " x " + displayLayout.height() + ". Video: " + videoWidth
             + " x " + videoHeight + ". Rotation: " + rotationDegree + ". Mirror: " + mirror);
         final float videoAspectRatio = (rotationDegree % 180 == 0)
             ? (float) videoWidth / videoHeight
             : (float) videoHeight / videoWidth;
         // Adjust display size based on |scalingType|.
         final Point displaySize = RendererCommon.getDisplaySize(scalingType,
             videoAspectRatio, displayLayout.width(), displayLayout.height());
         displayLayout.inset((displayLayout.width() - displaySize.x) / 2,
                             (displayLayout.height() - displaySize.y) / 2);
-        Log.d(TAG, "  Adjusted display size: " + displayLayout.width() + " x "
+        Logging.d(TAG, "  Adjusted display size: " + displayLayout.width() + " x "
             + displayLayout.height());
         layoutMatrix = RendererCommon.getLayoutMatrix(
             mirror, videoAspectRatio, (float) displayLayout.width() / displayLayout.height());
         updateLayoutProperties = false;
-        Log.d(TAG, "  AdjustTextureCoords done");
+        Logging.d(TAG, "  AdjustTextureCoords done");
       }
     }
 
     private void draw(GlRectDrawer drawer) {
       if (!seenFrame) {
         // No frame received yet - nothing to render.
         return;
       }
       long now = System.nanoTime();
 
@@ skipping 46 matching lines @@
         framesRendered++;
         drawTimeNs += (System.nanoTime() - now);
         if ((framesRendered % 300) == 0) {
           logStatistics();
         }
       }
     }
 
     private void logStatistics() {
       long timeSinceFirstFrameNs = System.nanoTime() - startTimeNs;
-      Log.d(TAG, "ID: " + id + ". Type: " + rendererType +
+      Logging.d(TAG, "ID: " + id + ". Type: " + rendererType +
           ". Frames received: " + framesReceived +
           ". Dropped: " + framesDropped + ". Rendered: " + framesRendered);
       if (framesReceived > 0 && framesRendered > 0) {
-        Log.d(TAG, "Duration: " + (int)(timeSinceFirstFrameNs / 1e6) +
+        Logging.d(TAG, "Duration: " + (int)(timeSinceFirstFrameNs / 1e6) +
             " ms. FPS: " + (float)framesRendered * 1e9 / timeSinceFirstFrameNs);
-        Log.d(TAG, "Draw time: " +
+        Logging.d(TAG, "Draw time: " +
             (int) (drawTimeNs / (1000 * framesRendered)) + " us. Copy time: " +
             (int) (copyTimeNs / (1000 * framesReceived)) + " us");
       }
     }
 
     public void setScreenSize(final int screenWidth, final int screenHeight) {
       synchronized(updateLayoutLock) {
         if (screenWidth == this.screenWidth && screenHeight == this.screenHeight) {
           return;
         }
-        Log.d(TAG, "ID: " + id + ". YuvImageRenderer.setScreenSize: " +
+        Logging.d(TAG, "ID: " + id + ". YuvImageRenderer.setScreenSize: " +
             screenWidth + " x " + screenHeight);
         this.screenWidth = screenWidth;
         this.screenHeight = screenHeight;
         updateLayoutProperties = true;
       }
     }
 
     public void setPosition(int x, int y, int width, int height,
         RendererCommon.ScalingType scalingType, boolean mirror) {
       final Rect layoutInPercentage =
           new Rect(x, y, Math.min(100, x + width), Math.min(100, y + height));
       synchronized(updateLayoutLock) {
         if (layoutInPercentage.equals(this.layoutInPercentage) && scalingType == this.scalingType
             && mirror == this.mirror) {
           return;
         }
-        Log.d(TAG, "ID: " + id + ". YuvImageRenderer.setPosition: (" + x + ", " + y +
+        Logging.d(TAG, "ID: " + id + ". YuvImageRenderer.setPosition: (" + x + ", " + y +
             ") " +  width + " x " + height + ". Scaling: " + scalingType +
             ". Mirror: " + mirror);
         this.layoutInPercentage.set(layoutInPercentage);
         this.scalingType = scalingType;
         this.mirror = mirror;
         updateLayoutProperties = true;
       }
     }
 
     private void setSize(final int videoWidth, final int videoHeight, final int rotation) {
       if (videoWidth == this.videoWidth && videoHeight == this.videoHeight
           && rotation == rotationDegree) {
         return;
       }
       if (rendererEvents != null) {
-        Log.d(TAG, "ID: " + id +
+        Logging.d(TAG, "ID: " + id +
             ". Reporting frame resolution changed to " + videoWidth + " x " + videoHeight);
         rendererEvents.onFrameResolutionChanged(videoWidth, videoHeight, rotation);
       }
 
       synchronized (updateLayoutLock) {
-        Log.d(TAG, "ID: " + id + ". YuvImageRenderer.setSize: " +
+        Logging.d(TAG, "ID: " + id + ". YuvImageRenderer.setSize: " +
             videoWidth + " x " + videoHeight + " rotation " + rotation);
 
         this.videoWidth = videoWidth;
         this.videoHeight = videoHeight;
         rotationDegree = rotation;
         updateLayoutProperties = true;
-        Log.d(TAG, "  YuvImageRenderer.setSize done.");
+        Logging.d(TAG, "  YuvImageRenderer.setSize done.");
       }
     }
 
     @Override
     public synchronized void renderFrame(I420Frame frame) {
       if (surface == null) {
         // This object has been released.
         VideoRenderer.renderFrameDone(frame);
         return;
       }
       if (!seenFrame && rendererEvents != null) {
-        Log.d(TAG, "ID: " + id + ". Reporting first rendered frame.");
+        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) {
-            Log.e(TAG, "Incorrect strides " + frame.yuvStrides[0] + ", " +
+            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);
           return;
         }
         pendingFrame = frame;
       }
       setSize(frame.width, frame.height, frame.rotationDegree);
       seenFrame = true;
 
       // Request rendering.
       surface.requestRender();
     }
   }
 
   /** Passes GLSurfaceView to video renderer. */
   public static synchronized void setView(GLSurfaceView surface,
       Runnable eglContextReadyCallback) {
-    Log.d(TAG, "VideoRendererGui.setView");
+    Logging.d(TAG, "VideoRendererGui.setView");
     instance = new VideoRendererGui(surface);
     eglContextReady = eglContextReadyCallback;
   }
 
   public static synchronized EGLContext getEGLContext() {
     return eglContext;
   }
 
   /** Releases GLSurfaceView video renderer. */
   public static synchronized void dispose() {
     if (instance == null){
       return;
     }
-    Log.d(TAG, "VideoRendererGui.dispose");
+    Logging.d(TAG, "VideoRendererGui.dispose");
     synchronized (instance.yuvImageRenderers) {
       for (YuvImageRenderer yuvImageRenderer : instance.yuvImageRenderers) {
         yuvImageRenderer.release();
       }
       instance.yuvImageRenderers.clear();
     }
     instance.surface = null;
     eglContext = null;
     eglContextReady = null;
     instance = null;
@@ skipping 60 matching lines @@
       }
       // Add yuv renderer to rendering list.
       instance.yuvImageRenderers.add(yuvImageRenderer);
     }
     return yuvImageRenderer;
   }
 
   public static synchronized void update(
       VideoRenderer.Callbacks renderer, int x, int y, int width, int height,
       RendererCommon.ScalingType scalingType, boolean mirror) {
-    Log.d(TAG, "VideoRendererGui.update");
+    Logging.d(TAG, "VideoRendererGui.update");
     if (instance == null) {
       throw new RuntimeException(
           "Attempt to update yuv renderer before setting GLSurfaceView");
     }
     synchronized (instance.yuvImageRenderers) {
       for (YuvImageRenderer yuvImageRenderer : instance.yuvImageRenderers) {
         if (yuvImageRenderer == renderer) {
           yuvImageRenderer.setPosition(x, y, width, height, scalingType, mirror);
         }
       }
     }
   }
 
   public static synchronized void setRendererEvents(
       VideoRenderer.Callbacks renderer, RendererCommon.RendererEvents rendererEvents) {
-    Log.d(TAG, "VideoRendererGui.setRendererEvents");
+    Logging.d(TAG, "VideoRendererGui.setRendererEvents");
     if (instance == null) {
       throw new RuntimeException(
           "Attempt to set renderer events before setting GLSurfaceView");
     }
     synchronized (instance.yuvImageRenderers) {
       for (YuvImageRenderer yuvImageRenderer : instance.yuvImageRenderers) {
         if (yuvImageRenderer == renderer) {
           yuvImageRenderer.rendererEvents = rendererEvents;
         }
       }
     }
   }
 
   public static synchronized void remove(VideoRenderer.Callbacks renderer) {
-    Log.d(TAG, "VideoRendererGui.remove");
+    Logging.d(TAG, "VideoRendererGui.remove");
     if (instance == null) {
       throw new RuntimeException(
           "Attempt to remove yuv renderer before setting GLSurfaceView");
     }
     synchronized (instance.yuvImageRenderers) {
       final int index = instance.yuvImageRenderers.indexOf(renderer);
       if (index == -1) {
-        Log.w(TAG, "Couldn't remove renderer (not present in current list)");
+        Logging.w(TAG, "Couldn't remove renderer (not present in current list)");
       } else {
         instance.yuvImageRenderers.remove(index).release();
       }
     }
   }
 
   @SuppressLint("NewApi")
   @Override
   public void onSurfaceCreated(GL10 unused, EGLConfig config) {
-    Log.d(TAG, "VideoRendererGui.onSurfaceCreated");
+    Logging.d(TAG, "VideoRendererGui.onSurfaceCreated");
     // Store render EGL context.
     if (CURRENT_SDK_VERSION >= EGL14_SDK_VERSION) {
       synchronized (VideoRendererGui.class) {
         eglContext = EGL14.eglGetCurrentContext();
-        Log.d(TAG, "VideoRendererGui EGL Context: " + eglContext);
+        Logging.d(TAG, "VideoRendererGui EGL Context: " + eglContext);
       }
     }
 
     synchronized (yuvImageRenderers) {
       // Create drawer for YUV/OES frames.
       drawer = new GlRectDrawer();
       // Create textures for all images.
       for (YuvImageRenderer yuvImageRenderer : yuvImageRenderers) {
         yuvImageRenderer.createTextures();
       }
       onSurfaceCreatedCalled = true;
     }
     GlUtil.checkNoGLES2Error("onSurfaceCreated done");
     GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 1);
     GLES20.glClearColor(0.15f, 0.15f, 0.15f, 1.0f);
 
     // Fire EGL context ready event.
     synchronized (VideoRendererGui.class) {
       if (eglContextReady != null) {
         eglContextReady.run();
       }
     }
   }
 
   @Override
   public void onSurfaceChanged(GL10 unused, int width, int height) {
-    Log.d(TAG, "VideoRendererGui.onSurfaceChanged: " +
+    Logging.d(TAG, "VideoRendererGui.onSurfaceChanged: " +
         width + " x " + height + "  ");
     screenWidth = width;
     screenHeight = height;
     synchronized (yuvImageRenderers) {
       for (YuvImageRenderer yuvImageRenderer : yuvImageRenderers) {
         yuvImageRenderer.setScreenSize(screenWidth, screenHeight);
       }
     }
   }
 
   @Override
   public void onDrawFrame(GL10 unused) {
     GLES20.glViewport(0, 0, screenWidth, screenHeight);
     GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
     synchronized (yuvImageRenderers) {
       for (YuvImageRenderer yuvImageRenderer : yuvImageRenderers) {
         yuvImageRenderer.draw(drawer);
       }
     }
   }
 
 }