Implement AndroidTextureBuffer::NativeToI420.

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

Index: talk/app/webrtc/java/android/org/webrtc/SurfaceTextureHelper.java
diff --git a/talk/app/webrtc/java/android/org/webrtc/SurfaceTextureHelper.java b/talk/app/webrtc/java/android/org/webrtc/SurfaceTextureHelper.java
index c730a41b61f34e84e368814150593de18d799fad..cf6fad4fc94cf7137c7b2ff4597be1ae7d2d9b84 100644
--- a/talk/app/webrtc/java/android/org/webrtc/SurfaceTextureHelper.java
+++ b/talk/app/webrtc/java/android/org/webrtc/SurfaceTextureHelper.java
@@ -35,6 +35,8 @@ import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.SystemClock;
 
+import java.nio.ByteBuffer;
+import java.nio.FloatBuffer;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
@@ -93,11 +95,214 @@ class SurfaceTextureHelper {
     });
   }
 
+  // State for YUV conversion, instantiated on demand.
+  static private class YuvConverter {
+    private final EglBase eglBase;
+    private final GlShader shader;
+    private boolean released = false;
+
+    // Vertex coordinates in Normalized Device Coordinates, i.e.
+    // (-1, -1) is bottom-left and (1, 1) is top-right.
+    private static final FloatBuffer DEVICE_RECTANGLE =
+        GlUtil.createFloatBuffer(new float[] {
+              -1.0f, -1.0f,  // Bottom left.
+               1.0f, -1.0f,  // Bottom right.
+              -1.0f,  1.0f,  // Top left.
+               1.0f,  1.0f,  // Top right.
+            });
+
+    // Texture coordinates - (0, 0) is bottom-left and (1, 1) is top-right.
+    private static final FloatBuffer TEXTURE_RECTANGLE =
+        GlUtil.createFloatBuffer(new float[] {
+              0.0f, 0.0f,  // Bottom left.
+              1.0f, 0.0f,  // Bottom right.
+              0.0f, 1.0f,  // Top left.
+              1.0f, 1.0f   // Top right.
+            });
+
+    private static final String VERTEX_SHADER =
+        "varying vec2 interp_tc;\n"
+      + "attribute vec4 in_pos;\n"
+      + "attribute vec4 in_tc;\n"
+      + "\n"
+      + "uniform mat4 texMatrix;\n"
+      + "\n"
+      + "void main() {\n"
+      + "    gl_Position = in_pos;\n"
+      + "    interp_tc = (texMatrix * in_tc).xy;\n"
+      + "}\n";
+
+    private static final String FRAGMENT_SHADER =
+        "#extension GL_OES_EGL_image_external : require\n"
+      + "precision mediump float;\n"
+      + "varying vec2 interp_tc;\n"
+      + "\n"
+      + "uniform samplerExternalOES oesTex;\n"
+      // Difference in texture coordinate corresponding to one
+      // sub-pixel in the x direction.
+      + "uniform vec2 xUnit;\n"
+      // Color conversion coefficients, including constant term
+      + "uniform vec4 coeffs;\n"
+      + "\n"
+      + "void main() {\n"
+      // Since the alpha read from the texture is always 1, this could
+      // be written as a mat4 x vec4 multiply. However, that seems to
+      // give a worse framerate, possibly because the additional
+      // multiplies by 1.0 consume resources. TODO(nisse): Could also
+      // try to do it as a vec3 x mat3x4, followed by an add in of a
+      // constant vector.
+      + "  gl_FragColor.r = coeffs.a + dot(coeffs.rgb,\n"
+      + "      texture2D(oesTex, interp_tc - 1.5 * xUnit).rgb);\n"
+      + "  gl_FragColor.g = coeffs.a + dot(coeffs.rgb,\n"
+      + "      texture2D(oesTex, interp_tc - 0.5 * xUnit).rgb);\n"
+      + "  gl_FragColor.b = coeffs.a + dot(coeffs.rgb,\n"
+      + "      texture2D(oesTex, interp_tc + 0.5 * xUnit).rgb);\n"
+      + "  gl_FragColor.a = coeffs.a + dot(coeffs.rgb,\n"
+      + "      texture2D(oesTex, interp_tc + 1.5 * xUnit).rgb);\n"
+      + "}\n";
+
+    private int texMatrixLoc;
+    private int xUnitLoc;
+    private int coeffsLoc;;
+
+    YuvConverter (EglBase.Context sharedContext) {
+      eglBase = EglBase.create(sharedContext, EglBase.CONFIG_PIXEL_RGBA_BUFFER);
+      eglBase.createDummyPbufferSurface();
+      eglBase.makeCurrent();
+
+      shader = new GlShader(VERTEX_SHADER, FRAGMENT_SHADER);
+      shader.useProgram();
+      texMatrixLoc = shader.getUniformLocation("texMatrix");
+      xUnitLoc = shader.getUniformLocation("xUnit");
+      coeffsLoc = shader.getUniformLocation("coeffs");
+      GLES20.glUniform1i(shader.getUniformLocation("oesTex"), 0);
+      GlUtil.checkNoGLES2Error("Initialize fragment shader uniform values.");
+      // Initialize vertex shader attributes.
+      shader.setVertexAttribArray("in_pos", 2, DEVICE_RECTANGLE);
+      // If the width is not a multiple of 4 pixels, the texture
+      // will be scaled up slightly and clipped at the right border.
+      shader.setVertexAttribArray("in_tc", 2, TEXTURE_RECTANGLE);
+    }
+
+    synchronized void convert(ByteBuffer buf,
+        int width, int height, int stride, int textureId, float [] transformMatrix) {
+      if (released) {
+        throw new IllegalStateException(
+            "YuvConverter.convert called on released object");
+      }
+      if (stride % 8 != 0) {
+        throw new IllegalArgumentException(
+            "Invalid stride, must be a multiple of 8");
+      }
+      if (stride < width){
+        throw new IllegalArgumentException(
+            "Invalid stride, must >= width");
+      }
+
+      int y_width = (width+3) / 4;
+      int uv_width = (width+7) / 8;
+      int uv_height = (height+1)/2;
+      int total_height = height + uv_height;
+      int size = stride * total_height;
+
+      if (buf.capacity() < size) {
+        throw new IllegalArgumentException("YuvConverter.convert called with too small buffer");
+      }
+      // Produce a frame buffer starting at top-left corner, not
+      // bottom-left.
+      transformMatrix =
+          RendererCommon.multiplyMatrices(transformMatrix,
+              RendererCommon.verticalFlipMatrix());
+
+      try {
+        // Reuse surface, if possible. TODO(nisse): Add an eglBase

[perkj_webrtc, 2015/12/09 09:28:28]

I would recommend to do this now or remove the todo. Todos have  way of never
getting fixed if they are not immedately attended to. I am fine with the way it
is. 

[nisse-webrtc, 2015/12/09 12:02:21]

I'm adding a helper function, withPbufferSurface. Or is it better to extend
createPbufferSurface to reuse 
or recreate the surface as needed?

+        // helper function, say, makeCurrentWithSize.
+        if (eglBase.hasSurface()) {
+          if (eglBase.surfaceWidth() != stride/4 ||
+              eglBase.surfaceHeight() != total_height){
+            eglBase.releaseSurface();
+            eglBase.createPbufferSurface(stride/4, total_height);
+          }
+        } else {
+          eglBase.createPbufferSurface(stride/4, total_height);
+        }
+
+        eglBase.makeCurrent();
+
+        GlUtil.checkNoGLES2Error("Initialize fragment shader uniform values.");

[perkj_webrtc, 2015/12/09 09:28:28]

Can we skip checking for error on every line. Just check at the bottom of this
method.

[nisse-webrtc, 2015/12/09 12:02:21]

Done.

+
+        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+        GlUtil.checkNoGLES2Error("Active texture");
+        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, textureId);
+        GLES20.glUniformMatrix4fv(texMatrixLoc, 1, false, transformMatrix, 0);
+
+        // Draw Y */
+        GLES20.glViewport(0, 0, y_width, height);
+        GlUtil.checkNoGLES2Error("Viewport");
+        // Matrix * (1;0;0;0) / width. Note that opengl uses column major order.
+        GLES20.glUniform2f(xUnitLoc,
+            transformMatrix[0] / width,
+            transformMatrix[1] / width);
+        // Y'UV444 to RGB888, see
+        // https://en.wikipedia.org/wiki/YUV#Y.27UV444_to_RGB888_conversion
+        GLES20.glUniform4f(coeffsLoc, 0.299f, 0.587f, 0.114f, 0.0f);
+        GlUtil.checkNoGLES2Error("Binding texture and matrix");
+
+        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
+        GlUtil.checkNoGLES2Error("glDrawArrays, Y");
+
+        // Draw U */
+        GLES20.glViewport(0, height, uv_width, uv_height);
+        GlUtil.checkNoGLES2Error("Viewport");
+        // Matrix * (1;0;0;0) / (2*width). Note that opengl uses column major order.
+        GLES20.glUniform2f(xUnitLoc,
+            transformMatrix[0] / (2.0f*width),
+            transformMatrix[1] / (2.0f*width));
+        /* Use ITU-R coefficients for U and V */
+        GLES20.glUniform4f(coeffsLoc, -0.169f, -0.331f, 0.499f, 0.5f);
+        GlUtil.checkNoGLES2Error("Binding texture and matrix");
+
+        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
+        GlUtil.checkNoGLES2Error("glDrawArrays, U");
+
+        // Draw V */
+        GLES20.glViewport(stride/8, height, uv_width, uv_height);
+        GlUtil.checkNoGLES2Error("Viewport");
+        /* Use ITU-R coefficients for U and V */
+        GLES20.glUniform4f(coeffsLoc, 0.499f, -0.418f, -0.0813f, 0.5f);
+        GlUtil.checkNoGLES2Error("Binding texture and matrix");
+
+        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
+        GlUtil.checkNoGLES2Error("glDrawArrays, V");
+
+        GLES20.glReadPixels(0, 0, stride/4, total_height, GLES20.GL_RGBA,
+            GLES20.GL_UNSIGNED_BYTE, buf);
+        GlUtil.checkNoGLES2Error("glReadPixels");
+
+        // Unbind texture. Reportedly needed on some devices to get
+        // the texture updated from the camera.
+        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, 0);
+      }
+      finally {
+        eglBase.detachCurrent();
+      }
+    }
+
+    synchronized public void release() {
+      released = true;
+      eglBase.makeCurrent();
+      shader.release();
+      eglBase.release();
+    }
+  }
+
   private final Handler handler;
   private boolean isOwningThread;
   private final EglBase eglBase;
   private final SurfaceTexture surfaceTexture;
   private final int oesTextureId;
+  private YuvConverter yuvConverter;
+
   private OnTextureFrameAvailableListener listener;
   // The possible states of this class.
   private boolean hasPendingTexture = false;
@@ -120,6 +325,18 @@ class SurfaceTextureHelper {
     surfaceTexture = new SurfaceTexture(oesTextureId);
   }
 
+  private YuvConverter getYuvConverter() {
+    // yuvConverter is assign once
+    if (yuvConverter != null)
+      return yuvConverter;
+
+    synchronized(this) {
+      if (yuvConverter == null)
+        yuvConverter = new YuvConverter(eglBase.getEglBaseContext());
+      return yuvConverter;
+    }
+  }
+
   /**
    *  Start to stream textures to the given |listener|.
    *  A Listener can only be set once.
@@ -207,6 +424,14 @@ class SurfaceTextureHelper {
     disconnect();
   }
 
+  public void textureToYUV(ByteBuffer buf,
+      int width, int height, int stride, int textureId, float [] transformMatrix) {
+    if (textureId != oesTextureId)
+      throw new IllegalStateException("textureToByteBuffer called with unexpected textureId");
+
+    getYuvConverter().convert(buf, width, height, stride, textureId, transformMatrix);
+  }
+
   private void tryDeliverTextureFrame() {
     if (handler.getLooper().getThread() != Thread.currentThread()) {
       throw new IllegalStateException("Wrong thread.");
@@ -235,6 +460,10 @@ class SurfaceTextureHelper {
     if (isTextureInUse || !isQuitting) {
       throw new IllegalStateException("Unexpected release.");
     }
+    synchronized (this) {
+      if (yuvConverter != null)
+        yuvConverter.release();
+    }
     eglBase.makeCurrent();
     GLES20.glDeleteTextures(1, new int[] {oesTextureId}, 0);
     surfaceTexture.release();