ran git cl format webrtc/sdk/android/

webrtc/sdk/android/api/org/webrtc/TextureViewRenderer.java

 /*
  *  Copyright 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 package org.webrtc;
 
 import android.content.Context;
 import android.content.res.Resources.NotFoundException;
+import android.graphics.Matrix;
 import android.graphics.Point;
+import android.graphics.SurfaceTexture;
 import android.util.AttributeSet;
+import android.view.Surface;
 import android.view.SurfaceHolder;
-import android.view.SurfaceView;
+import android.view.TextureView;
+import android.view.TextureView.SurfaceTextureListener;
+
 import java.util.concurrent.CountDownLatch;
 
 /**
  * Implements org.webrtc.VideoRenderer.Callbacks by displaying the video stream on a SurfaceView.
  * renderFrame() is asynchronous to avoid blocking the calling thread.
  * This class is thread safe and handles access from potentially four different threads:
  * Interaction from the main app in init, release, setMirror, and setScalingtype.
  * Interaction from C++ rtc::VideoSinkInterface in renderFrame.
  * Interaction from the Activity lifecycle in surfaceCreated, surfaceChanged, and surfaceDestroyed.
  * Interaction with the layout framework in onMeasure and onSizeChanged.
  */
-public class SurfaceViewRenderer
-    extends SurfaceView implements SurfaceHolder.Callback, VideoRenderer.Callbacks {
+public class TextureViewRenderer extends TextureView
+    implements SurfaceHolder.Callback, SurfaceTextureListener, VideoRenderer.Callbacks {
   private static final String TAG = "SurfaceViewRenderer";
 
   // Cached resource name.
   private final String resourceName;
   private final RendererCommon.VideoLayoutMeasure videoLayoutMeasure =
       new RendererCommon.VideoLayoutMeasure();
   private final EglRenderer eglRenderer;
 
   // Callback for reporting renderer events. Read-only after initilization so no lock required.
   private RendererCommon.RendererEvents rendererEvents;
 
   private final Object layoutLock = new Object();
   private boolean isFirstFrameRendered;
   private int rotatedFrameWidth;
   private int rotatedFrameHeight;
   private int frameRotation;
 
   // Accessed only on the main thread.
   private boolean enableFixedSize;
   private int surfaceWidth;
   private int surfaceHeight;
 
   /**
    * Standard View constructor. In order to render something, you must first call init().
    */
-  public SurfaceViewRenderer(Context context) {
+  public TextureViewRenderer(Context context) {
     super(context);
     this.resourceName = getResourceName();
     eglRenderer = new EglRenderer(resourceName);
-    getHolder().addCallback(this);
+    setSurfaceTextureListener(this);
   }
 
   /**
    * Standard View constructor. In order to render something, you must first call init().
    */
-  public SurfaceViewRenderer(Context context, AttributeSet attrs) {
+  public TextureViewRenderer(Context context, AttributeSet attrs) {
     super(context, attrs);
     this.resourceName = getResourceName();
     eglRenderer = new EglRenderer(resourceName);
-    getHolder().addCallback(this);
+    setSurfaceTextureListener(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(EglBase.Context sharedContext, RendererCommon.RendererEvents rendererEvents) {
     init(sharedContext, rendererEvents, EglBase.CONFIG_PLAIN, new GlRectDrawer());
   }
 
@@ skipping 26 matching lines @@
     eglRenderer.release();
   }
 
   /**
    * Register a callback to be invoked when a new video frame has been received.
    *
    * @param listener The callback to be invoked. The callback will be invoked on the render thread.
    *                 It should be lightweight and must not call removeFrameListener.
    * @param scale    The scale of the Bitmap passed to the callback, or 0 if no Bitmap is
    *                 required.
-   * @param drawer   Custom drawer to use for this frame listener.
+   * @param drawerParam   Custom drawer to use for this frame listener.
    */
   public void addFrameListener(
       EglRenderer.FrameListener listener, float scale, RendererCommon.GlDrawer drawerParam) {
     eglRenderer.addFrameListener(listener, scale, drawerParam);
   }
 
   /**
    * Register a callback to be invoked when a new video frame has been received. This version uses
    * the drawer of the EglRenderer that was passed in init.
    *
@@ skipping 104 matching lines @@
         }
         // Aspect ratio of the drawn frame and the view is the same.
         final int width = Math.min(getWidth(), drawnFrameWidth);
         final int height = Math.min(getHeight(), drawnFrameHeight);
         logD("updateSurfaceSize. Layout size: " + getWidth() + "x" + getHeight() + ", frame size: "
             + rotatedFrameWidth + "x" + rotatedFrameHeight + ", requested surface size: " + width
             + "x" + height + ", old surface size: " + surfaceWidth + "x" + surfaceHeight);
         if (width != surfaceWidth || height != surfaceHeight) {
           surfaceWidth = width;
           surfaceHeight = height;
-          getHolder().setFixedSize(width, height);
+          adjustAspectRatio(surfaceWidth, surfaceHeight);

[sakal, 2017/06/16 07:47:02]

This doesn't change the surface size?

         }
       } else {
         surfaceWidth = surfaceHeight = 0;

[sakal, 2017/06/16 07:47:02]

We have to somehow reset the surface size

-        getHolder().setSizeFromLayout();
       }
     }
   }
 
+  /**
+   * Sets the TextureView transform to preserve the aspect ratio of the video.
+   */
+  private void adjustAspectRatio(int videoWidth, int videoHeight) {

[sakal, 2017/06/16 07:47:02]

This method is not needed if you correctly call setLayoutAspectRatio, it set a
matrix that renders correctly on the surface.

+    int viewWidth = getWidth();
+    int viewHeight = getHeight();
+    double aspectRatio = (double) videoHeight / videoWidth;
+
+    int newWidth, newHeight;
+    if (viewHeight > (int) (viewWidth * aspectRatio)) {
+      // limited by narrow width; restrict height
+      newWidth = viewWidth;
+      newHeight = (int) (viewWidth * aspectRatio);
+    } else {
+      // limited by short height; restrict width
+      newWidth = (int) (viewHeight / aspectRatio);
+      newHeight = viewHeight;
+    }
+    int xoff = (viewWidth - newWidth) / 2;
+    int yoff = (viewHeight - newHeight) / 2;
+    logD("video=" + videoWidth + "x" + videoHeight + " view=" + viewWidth + "x" + viewHeight
+        + " newView=" + newWidth + "x" + newHeight + " off=" + xoff + "," + yoff);
+
+    Matrix txform = new Matrix();
+    getTransform(txform);
+    txform.setScale((float) newWidth / viewWidth, (float) newHeight / viewHeight);
+    // txform.postRotate(10);          // just for fun
+    txform.postTranslate(xoff, yoff);
+    setTransform(txform);
+  }
+
   // SurfaceHolder.Callback interface.
   @Override
   public void surfaceCreated(final SurfaceHolder holder) {
     ThreadUtils.checkIsOnMainThread();
     eglRenderer.createEglSurface(holder.getSurface());
     surfaceWidth = surfaceHeight = 0;
     updateSurfaceSize();
   }
 
   @Override
   public void surfaceDestroyed(SurfaceHolder holder) {
     ThreadUtils.checkIsOnMainThread();
     final CountDownLatch completionLatch = new CountDownLatch(1);
     eglRenderer.releaseEglSurface(new Runnable() {
       @Override
       public void run() {
         completionLatch.countDown();
       }
     });
     ThreadUtils.awaitUninterruptibly(completionLatch);
   }
 
   @Override
   public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
     ThreadUtils.checkIsOnMainThread();
     logD("surfaceChanged: format: " + format + " size: " + width + "x" + height);
   }
 
+  // TextureView.SurfaceTextureListener implementation
+  @Override
+  public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int i, int i1) {
+    ThreadUtils.checkIsOnMainThread();
+    eglRenderer.createEglSurface(new Surface(surfaceTexture));
+    surfaceWidth = surfaceHeight = 0;
+    updateSurfaceSize();
+  }
+
+  @Override
+  public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, int width, int height) {
+    ThreadUtils.checkIsOnMainThread();
+    logD("surfaceChanged: size: " + width + "x" + height);
+  }
+
+  @Override
+  public boolean onSurfaceTextureDestroyed(SurfaceTexture surfaceTexture) {
+    ThreadUtils.checkIsOnMainThread();
+    final CountDownLatch completionLatch = new CountDownLatch(1);
+    eglRenderer.releaseEglSurface(new Runnable() {
+      @Override
+      public void run() {
+        completionLatch.countDown();
+      }
+    });
+    ThreadUtils.awaitUninterruptibly(completionLatch);
+    return true;
+  }
+
+  @Override
+  public void onSurfaceTextureUpdated(SurfaceTexture surfaceTexture) {}
+
   private String getResourceName() {
     try {
       return getResources().getResourceEntryName(getId()) + ": ";
     } catch (NotFoundException e) {
       return "";
     }
   }
 
   /**
    * Post a task to clear the SurfaceView to a transparent uniform color.
@@ skipping 30 matching lines @@
           }
         });
       }
     }
   }
 
   private void logD(String string) {
     Logging.d(TAG, resourceName + string);
   }
 }