Android: Add helper class VideoFrameDrawer that can render VideoFrames

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

 /*
  *  Copyright 2016 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.
  */
 
@@ skipping 78 matching lines @@
   private final Object fpsReductionLock = new Object();
   // Time for when next frame should be rendered.
   private long nextFrameTimeNs;
   // Minimum duration between frames when fps reduction is active, or -1 if video is completely
   // paused.
   private long minRenderPeriodNs;
 
   // EGL and GL resources for drawing YUV/OES textures. After initilization, these are only accessed
   // from the render thread.
   private EglBase eglBase;
-  private final RendererCommon.YuvUploader yuvUploader = new RendererCommon.YuvUploader();
+  private final VideoFrameDrawer frameDrawer = new VideoFrameDrawer();
   private RendererCommon.GlDrawer drawer;
+  private final Matrix drawMatrix = new Matrix();
 
   // Pending frame to render. Serves as a queue with size 1. Synchronized on |frameLock|.
   private final Object frameLock = new Object();
   private VideoFrame pendingFrame;
 
   // These variables are synchronized on |layoutLock|.
   private final Object layoutLock = new Object();
   private float layoutAspectRatio;
   // If true, mirrors the video stream horizontally.
   private boolean mirror;
@@ skipping 109 matching lines @@
         logD("Already released");
         return;
       }
       renderThreadHandler.removeCallbacks(logStatisticsRunnable);
       // Release EGL and GL resources on render thread.
       renderThreadHandler.postAtFrontOfQueue(() -> {
         if (drawer != null) {
           drawer.release();
           drawer = null;
         }
-        yuvUploader.release();
+        frameDrawer.release();
         if (bitmapTextureFramebuffer != null) {
           bitmapTextureFramebuffer.release();
           bitmapTextureFramebuffer = null;
         }
         if (eglBase != null) {
           logD("eglBase detach and release.");
           eglBase.detachCurrent();
           eglBase.release();
           eglBase = null;
         }
@@ skipping 312 matching lines @@
     }
 
     final long startTimeNs = System.nanoTime();
 
     final float frameAspectRatio = frame.getRotatedWidth() / (float) frame.getRotatedHeight();
     final float drawnAspectRatio;
     synchronized (layoutLock) {
       drawnAspectRatio = layoutAspectRatio != 0f ? layoutAspectRatio : frameAspectRatio;
     }
 
-    VideoFrame.Buffer buffer = frame.getBuffer();
-    final boolean isYuvBuffer;
-    if (buffer instanceof VideoFrame.TextureBuffer) {
-      isYuvBuffer = false;
-    } else {
-      isYuvBuffer = true;
-      VideoFrame.Buffer oldBuffer = buffer;
-      buffer = buffer.toI420();
-      oldBuffer.release();
-    }
-    boolean shouldUploadYuvTextures = false;
-    if (isYuvBuffer) {
-      shouldUploadYuvTextures = shouldRenderFrame;
-      // Check if there are frame listeners that we want to render a bitmap for regardless of if the
-      // frame was rendered. This is the case when there are frameListeners with scale != 0f.
-      if (!shouldUploadYuvTextures) {
-        for (FrameListenerAndParams listenerAndParams : frameListeners) {
-          if (listenerAndParams.scale != 0f
-              && (shouldRenderFrame || !listenerAndParams.applyFpsReduction)) {
-            shouldUploadYuvTextures = true;
-            break;
-          }
-        }
-      }
-    }
-    final int[] yuvTextures = shouldUploadYuvTextures
-        ? yuvUploader.uploadFromBuffer((VideoFrame.I420Buffer) buffer)
-        : null;
-
     final float scaleX;
     final float scaleY;
 
     if (frameAspectRatio > drawnAspectRatio) {
       scaleX = drawnAspectRatio / frameAspectRatio;
       scaleY = 1f;
     } else {
       scaleX = 1f;
       scaleY = frameAspectRatio / drawnAspectRatio;
     }
 
-    final int drawnFrameWidth = (int) (scaleX * frame.getRotatedWidth());
-    final int drawnFrameHeight = (int) (scaleY * frame.getRotatedHeight());
-
-    final Matrix drawMatrix = new Matrix();
+    drawMatrix.reset();
     drawMatrix.preTranslate(0.5f, 0.5f);
-    if (isYuvBuffer)
-      drawMatrix.preScale(1f, -1f); // I420-frames are upside down
-    drawMatrix.preRotate(frame.getRotation());
     if (mirror)
       drawMatrix.preScale(-1f, 1f);
     drawMatrix.preScale(scaleX, scaleY);
     drawMatrix.preTranslate(-0.5f, -0.5f);
 
     if (shouldRenderFrame) {
       GLES20.glClearColor(0 /* red */, 0 /* green */, 0 /* blue */, 0 /* alpha */);
       GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
-      if (isYuvBuffer) {
-        drawer.drawYuv(yuvTextures,
-            RendererCommon.convertMatrixFromAndroidGraphicsMatrix(drawMatrix), drawnFrameWidth,
-            drawnFrameHeight, 0, 0, eglBase.surfaceWidth(), eglBase.surfaceHeight());
-      } else {
-        VideoFrame.TextureBuffer textureBuffer = (VideoFrame.TextureBuffer) buffer;
-        RendererCommon.drawTexture(drawer, textureBuffer, drawMatrix, drawnFrameWidth,
-            drawnFrameHeight, 0, 0, eglBase.surfaceWidth(), eglBase.surfaceHeight());
-      }
+      frameDrawer.drawFrame(frame, drawer, drawMatrix, 0 /* viewportX */, 0 /* viewportY */,
+          eglBase.surfaceWidth(), eglBase.surfaceHeight());
 
       final long swapBuffersStartTimeNs = System.nanoTime();
       eglBase.swapBuffers();
 
       final long currentTimeNs = System.nanoTime();
       synchronized (statisticsLock) {
         ++framesRendered;
         renderTimeNs += (currentTimeNs - startTimeNs);
         renderSwapBufferTimeNs += (currentTimeNs - swapBuffersStartTimeNs);
       }
     }
 
-    notifyCallbacks(frame, isYuvBuffer, yuvTextures, shouldRenderFrame);
-    buffer.release();
+    notifyCallbacks(frame, shouldRenderFrame);
+    frame.release();
   }
 
-  private void notifyCallbacks(
-      VideoFrame frame, boolean isYuvBuffer, int[] yuvTextures, boolean wasRendered) {
+  private void notifyCallbacks(VideoFrame frame, boolean wasRendered) {
     if (frameListeners.isEmpty())
       return;
 
-    final Matrix drawMatrix = new Matrix();
+    drawMatrix.reset();
     drawMatrix.preTranslate(0.5f, 0.5f);
-    if (isYuvBuffer)
-      drawMatrix.preScale(1f, -1f); // I420-frames are upside down
-    drawMatrix.preRotate(frame.getRotation());
     if (mirror)
       drawMatrix.preScale(-1f, 1f);
     drawMatrix.preScale(1f, -1f); // We want the output to be upside down for Bitmap.
     drawMatrix.preTranslate(-0.5f, -0.5f);
 
     Iterator<FrameListenerAndParams> it = frameListeners.iterator();
     while (it.hasNext()) {
       FrameListenerAndParams listenerAndParams = it.next();
       if (!wasRendered && listenerAndParams.applyFpsReduction) {
         continue;
@@ skipping 12 matching lines @@
         bitmapTextureFramebuffer = new GlTextureFrameBuffer(GLES20.GL_RGBA);
       }
       bitmapTextureFramebuffer.setSize(scaledWidth, scaledHeight);
 
       GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, bitmapTextureFramebuffer.getFrameBufferId());
       GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0,
           GLES20.GL_TEXTURE_2D, bitmapTextureFramebuffer.getTextureId(), 0);
 
       GLES20.glClearColor(0 /* red */, 0 /* green */, 0 /* blue */, 0 /* alpha */);
       GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
-      if (isYuvBuffer) {
-        listenerAndParams.drawer.drawYuv(yuvTextures,
-            RendererCommon.convertMatrixFromAndroidGraphicsMatrix(drawMatrix),
-            frame.getRotatedWidth(), frame.getRotatedHeight(), 0, 0, scaledWidth, scaledHeight);
-      } else {
-        VideoFrame.TextureBuffer textureBuffer = (VideoFrame.TextureBuffer) frame.getBuffer();
-        RendererCommon.drawTexture(listenerAndParams.drawer, textureBuffer, drawMatrix,
-            frame.getRotatedWidth(), frame.getRotatedHeight(), 0, 0, scaledWidth, scaledHeight);
-      }
+      frameDrawer.drawFrame(frame, listenerAndParams.drawer, drawMatrix, 0 /* viewportX */,
+          0 /* viewportY */, scaledWidth, scaledHeight);
 
       final ByteBuffer bitmapBuffer = ByteBuffer.allocateDirect(scaledWidth * scaledHeight * 4);
       GLES20.glViewport(0, 0, scaledWidth, scaledHeight);
       GLES20.glReadPixels(
           0, 0, scaledWidth, scaledHeight, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, bitmapBuffer);
 
       GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
       GlUtil.checkNoGLES2Error("EglRenderer.notifyCallbacks");
 
       final Bitmap bitmap = Bitmap.createBitmap(scaledWidth, scaledHeight, Bitmap.Config.ARGB_8888);
@@ skipping 23 matching lines @@
           + " Average swapBuffer time: "
           + averageTimeAsString(renderSwapBufferTimeNs, framesRendered) + ".");
       resetStatistics(currentTimeNs);
     }
   }
 
   private void logD(String string) {
     Logging.d(TAG, name + string);
   }
 }