Support for video file instead of camera and output video out to file

webrtc/api/android/java/src/org/webrtc/GlVideoFileDrawer.java

Index: webrtc/api/android/java/src/org/webrtc/GlVideoFileDrawer.java
diff --git a/webrtc/api/android/java/src/org/webrtc/GlVideoFileDrawer.java b/webrtc/api/android/java/src/org/webrtc/GlVideoFileDrawer.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd3c147172863948883418c0ade34db54fb1b8d8
--- /dev/null
+++ b/webrtc/api/android/java/src/org/webrtc/GlVideoFileDrawer.java
@@ -0,0 +1,126 @@
+/*
+ *  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.
+ */
+package org.webrtc;
+
+import java.nio.ByteBuffer;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+public class GlVideoFileDrawer implements RendererCommon.GlDrawer {

[magjed_webrtc, 2016/08/31 13:08:03]

I don't think this is the best approach, I think you should implement
VideoRenderer.Callbacks instead. If you want to preserve remote rendering when
capturing to a file, you can add multiple renderers to the remote video track.

+  private static final String TAG = "GlVideoFileDrawer";
+
+  private SurfaceTextureHelper surfaceTextureHelper;
+
+  // We want to keep old drawing calls, and add our own. This is the old
+  // drawer that we should also call.
+  private RendererCommon.GlDrawer decoratedDrawer;
+
+  //private String outputFileName;
+  private FileOutputStream videoOutFile;
+  private int outputFileWidth;
+  private int outputFileHeight;
+
+  public GlVideoFileDrawer(
+      String outputFile, int outputFileWidth, int outputFileHeight,
+      EglBase.Context sharedContext, RendererCommon.GlDrawer decoratedDrawer) {
+    this.decoratedDrawer = decoratedDrawer;
+    surfaceTextureHelper = SurfaceTextureHelper.create(

[magjed_webrtc, 2016/08/31 14:10:46]

The SurfaceTextureHelper will create a SurfaceTexture and some other GL stuff
that you don't need. Create a YuvConverter directly instead.

[mandermo, 2016/09/16 12:32:30]

Done.

+        "Stubbed camera conversion", sharedContext);
+    this.outputFileWidth = outputFileWidth;
+    this.outputFileHeight = outputFileHeight;
+    try {
+      videoOutFile = new FileOutputStream(outputFile);
+      videoOutFile.write((
+            "YUV4MPEG2 C420 W" + outputFileWidth +
+            " H" + outputFileHeight + " Ip F30:1 A1:1\n").getBytes());
+    }
+    catch (IOException e) {
+      Logging.d(TAG, "Failed to open file to print video out");
+    }
+  }
+
+  @Override
+  public void drawOes(int oesTextureId, float[] texMatrix,
+      int frameWidth, int frameHeight,
+      int viewportX, int viewportY, int viewportWidth, int viewportHeight) {
+    if (decoratedDrawer != null) {
+      decoratedDrawer.drawOes(oesTextureId, texMatrix, frameWidth, frameHeight,
+          viewportX, viewportY, viewportWidth, viewportHeight);
+    }
+
+    if (videoOutFile == null) {
+      return;
+    }
+    int frameSize = outputFileWidth*outputFileHeight*3/2;
+    ByteBuffer frameBytes = ByteBuffer.allocateDirect(frameSize);
+
+    Logging.d(TAG, "Before convert()");
+    surfaceTextureHelper.getYuvConverter().convert(
+        frameBytes, outputFileWidth, outputFileHeight, outputFileWidth,
+        oesTextureId, texMatrix);
+    Logging.d(TAG, "After convert()");
+
+    try {
+      videoOutFile.write("FRAME\n".getBytes());
+
+      int width = outputFileWidth;
+      int height = outputFileHeight;
+      int stride = width;
+      byte[] data = frameBytes.array();
+      int offset = frameBytes.arrayOffset();
+
+      Logging.d(TAG,
+          "arrayOffset(): " + frameBytes.arrayOffset() +
+          " hasArray: " + frameBytes.hasArray());
+      // Write Y
+      videoOutFile.write(data, offset, width*height);
+
+      // Write U
+      for (int r = height; r<height*3/2; ++r) {
+        videoOutFile.write(data, offset + r * stride, stride / 2);
+      }
+
+      // Write V
+      for (int r = height; r<height*3/2; ++r) {
+        videoOutFile.write(data, offset + r * stride + stride / 2, stride / 2);
+      }
+    }
+    catch (IOException e) {
+      Logging.d(TAG, "Failed to write to file for video out");
+    }
+  }
+
+  @Override
+  public void drawRgb(int textureId, float[] texMatrix,
+      int frameWidth, int frameHeight,
+      int viewportX, int viewportY, int viewportWidth, int viewportHeight) {
+    if (decoratedDrawer != null) {
+      decoratedDrawer.drawRgb(textureId, texMatrix, frameWidth, frameHeight,
+          viewportX, viewportY, viewportWidth, viewportHeight);
+    }
+  }
+
+  @Override
+  public void drawYuv(int[] yuvTextures, float[] texMatrix, int frameWidth, int frameHeight,
+      int viewportX, int viewportY, int viewportWidth, int viewportHeight) {
+    if (decoratedDrawer != null) {
+      decoratedDrawer.drawYuv(yuvTextures, texMatrix, frameWidth, frameHeight,
+          viewportX, viewportY, viewportWidth, viewportHeight);
+    }
+  }
+
+  @Override
+  public void release() {
+    if (decoratedDrawer != null) {
+      decoratedDrawer.release();
+    }
+  }
+}
+