Java VideoRenderer.Callbacks: Make renderFrame() interface asynchronous

talk/app/webrtc/java/src/org/webrtc/VideoRenderer.java

 /*
  * libjingle
  * Copyright 2013 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 24 matching lines @@
  * class also provides a createGui() method for creating a GUI-rendering window
  * on various platforms.
  */
 public class VideoRenderer {
 
   /** Java version of cricket::VideoFrame. */
   public static class I420Frame {
     public final int width;
     public final int height;
     public final int[] yuvStrides;
-    public final ByteBuffer[] yuvPlanes;
+    public ByteBuffer[] yuvPlanes;
     public final boolean yuvFrame;
     public Object textureObject;
     public int textureId;
+    // If |nativeFramePointer| is non-zero, the memory is allocated on the C++ side.
+    private long nativeFramePointer;
 
     // rotationDegree is the degree that the frame must be rotated clockwisely
     // to be rendered correctly.
     public int rotationDegree;
 
     /**
      * Construct a frame of the given dimensions with the specified planar
      * data.  If |yuvPlanes| is null, new planes of the appropriate sizes are
      * allocated.
      */
     public I420Frame(
         int width, int height, int rotationDegree,
-        int[] yuvStrides, ByteBuffer[] yuvPlanes) {
+        int[] yuvStrides, ByteBuffer[] yuvPlanes, long nativeFramePointer) {
       this.width = width;
       this.height = height;
       this.yuvStrides = yuvStrides;
       if (yuvPlanes == null) {
         yuvPlanes = new ByteBuffer[3];
         yuvPlanes[0] = ByteBuffer.allocateDirect(yuvStrides[0] * height);
         yuvPlanes[1] = ByteBuffer.allocateDirect(yuvStrides[1] * height / 2);
         yuvPlanes[2] = ByteBuffer.allocateDirect(yuvStrides[2] * height / 2);
       }
       this.yuvPlanes = yuvPlanes;
       this.yuvFrame = true;
       this.rotationDegree = rotationDegree;
+      this.nativeFramePointer = nativeFramePointer;
       if (rotationDegree % 90 != 0) {
         throw new IllegalArgumentException("Rotation degree not multiple of 90: " + rotationDegree);
       }
     }
 
     /**
      * Construct a texture frame of the given dimensions with data in SurfaceTexture
      */
     public I420Frame(
         int width, int height, int rotationDegree,
-        Object textureObject, int textureId) {
+        Object textureObject, int textureId, long nativeFramePointer) {
       this.width = width;
       this.height = height;
       this.yuvStrides = null;
       this.yuvPlanes = null;
       this.textureObject = textureObject;
       this.textureId = textureId;
       this.yuvFrame = false;
       this.rotationDegree = rotationDegree;
+      this.nativeFramePointer = nativeFramePointer;
       if (rotationDegree % 90 != 0) {
         throw new IllegalArgumentException("Rotation degree not multiple of 90: " + rotationDegree);
       }
     }
 
     public int rotatedWidth() {
       return (rotationDegree % 180 == 0) ? width : height;
     }
 
     public int rotatedHeight() {
       return (rotationDegree % 180 == 0) ? height : width;
     }
 
     /**
      * Copy the planes out of |source| into |this| and return |this|.  Calling
      * this with mismatched frame dimensions or frame type is a programming
      * error and will likely crash.
      */
     public I420Frame copyFrom(I420Frame source) {
+      // |nativeFramePointer| is not copied from |source|, because resources in this object are
+      // still allocated in Java. After copyFrom() is done, this object should not hold any
+      // references to |source|. This is violated for texture frames however, because |textureId|
+      // is copied without making a deep copy.
+      if (this.nativeFramePointer != 0) {
+        throw new RuntimeException("Trying to overwrite a frame allocated in C++");
+      }
       if (source.yuvFrame && yuvFrame) {
         if (width != source.width || height != source.height) {
           throw new RuntimeException("Mismatched dimensions!  Source: " +
               source.toString() + ", destination: " + toString());
         }
         nativeCopyPlane(source.yuvPlanes[0], width, height,
             source.yuvStrides[0], yuvPlanes[0], yuvStrides[0]);
         nativeCopyPlane(source.yuvPlanes[1], width / 2, height / 2,
             source.yuvStrides[1], yuvPlanes[1], yuvStrides[1]);
         nativeCopyPlane(source.yuvPlanes[2], width / 2, height / 2,
@@ skipping 41 matching lines @@
     }
   }
 
   // Helper native function to do a video frame plane copying.
   private static native void nativeCopyPlane(ByteBuffer src, int width,
       int height, int srcStride, ByteBuffer dst, int dstStride);
 
   /** The real meat of VideoRendererInterface. */
   public static interface Callbacks {
     // |frame| might have pending rotation and implementation of Callbacks
-    // should handle that by applying rotation during rendering.
+    // should handle that by applying rotation during rendering. The callee
+    // is responsible for signaling when it is done with |frame| by calling
+    // renderFrameDone(frame).
     public void renderFrame(I420Frame frame);
   }
 
+   /**
+    * This must be called after every renderFrame() to release the frame.
+    */
+   public static void renderFrameDone(I420Frame frame) {
+     frame.yuvPlanes = null;
+     frame.textureObject = null;
+     frame.textureId = 0;
+     if (frame.nativeFramePointer != 0) {
+       releaseNativeFrame(frame.nativeFramePointer);
+       frame.nativeFramePointer = 0;
+     }
+   }
+
   // |this| either wraps a native (GUI) renderer or a client-supplied Callbacks
   // (Java) implementation; this is indicated by |isWrappedVideoRenderer|.
   long nativeVideoRenderer;
   private final boolean isWrappedVideoRenderer;
 
   public static VideoRenderer createGui(int x, int y) {
     long nativeVideoRenderer = nativeCreateGuiVideoRenderer(x, y);
     if (nativeVideoRenderer == 0) {
       return null;
     }
@@ skipping 21 matching lines @@
       freeWrappedVideoRenderer(nativeVideoRenderer);
     }
     nativeVideoRenderer = 0;
   }
 
   private static native long nativeCreateGuiVideoRenderer(int x, int y);
   private static native long nativeWrapVideoRenderer(Callbacks callbacks);
 
   private static native void freeGuiVideoRenderer(long nativeVideoRenderer);
   private static native void freeWrappedVideoRenderer(long nativeVideoRenderer);
+
+  private static native void releaseNativeFrame(long nativeFramePointer);
 }