Revert of Android VideoCapturer: Send ByteBuffer instead of byte[]

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

 /*
  * libjingle
  * Copyright 2015 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 551 matching lines @@
     final long captureTimeNs =
         TimeUnit.MILLISECONDS.toNanos(SystemClock.elapsedRealtime());
 
     captureBuffersCount += videoBuffers.numCaptureBuffersAvailable();
     int rotation = getDeviceOrientation();
     if (info.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
       rotation = 360 - rotation;
     }
     rotation = (info.orientation + rotation) % 360;
     // Mark the frame owning |data| as used.
-    final ByteBuffer buffer = videoBuffers.reserveByteBuffer(data, captureTimeNs);
-    if (buffer != null) {
+    // Note that since data is directBuffer,
+    // data.length >= videoBuffers.frameSize.
+    if (videoBuffers.reserveByteBuffer(data, captureTimeNs)) {
       cameraFramesCount++;
-      frameObserver.OnFrameCaptured(buffer, captureFormat.width, captureFormat.height,
-          rotation, captureTimeNs);
+      frameObserver.OnFrameCaptured(data, videoBuffers.frameSize, captureFormat.width,
+          captureFormat.height, rotation, captureTimeNs);
     } else {
       Logging.w(TAG, "reserveByteBuffer failed - dropping frame.");
     }
   }
 
   // Class used for allocating and bookkeeping video frames. All buffers are
   // direct allocated so that they can be directly used from native code. This class is
   // not thread-safe, and enforces single thread use.
   private static class FramePool {
     // Thread that all calls should be made on.
@@ skipping 61 matching lines @@
       checkIsOnValidThread();
       this.camera = null;
       queuedBuffers.clear();
       // Frames in |pendingBuffers| need to be kept alive until they are returned.
       Logging.d(TAG, "stopReturnBuffersToCamera called."
             + (pendingBuffers.isEmpty() ?
                    " All buffers have been returned."
                    : " Pending buffers: " + pendingFramesTimeStamps() + "."));
     }
 
-    // Returns the reserved byte buffer, or null on failure.
-    public ByteBuffer reserveByteBuffer(byte[] data, long timeStamp) {
+    public boolean reserveByteBuffer(byte[] data, long timeStamp) {
       checkIsOnValidThread();
       final ByteBuffer buffer = queuedBuffers.remove(data);
       if (buffer == null) {
         // Frames might be posted to |onPreviewFrame| with the previous format while changing
         // capture format in |startPreviewOnCameraThread|. Drop these old frames.
         Logging.w(TAG, "Received callback buffer from previous configuration with length: "
             + (data == null ? "null" : data.length));
-        return null;
+        return false;
       }
       if (buffer.capacity() != frameSize) {
         throw new IllegalStateException("Callback buffer has unexpected frame size");
       }
       if (pendingBuffers.containsKey(timeStamp)) {
         Logging.e(TAG, "Timestamp already present in pending buffers - they need to be unique");
-        return null;
+        return false;
       }
       pendingBuffers.put(timeStamp, buffer);
       if (queuedBuffers.isEmpty()) {
         Logging.v(TAG, "Camera is running out of capture buffers."
             + " Pending buffers: " + pendingFramesTimeStamps());
       }
-      return buffer;
+      return true;
     }
 
     public void returnBuffer(long timeStamp) {
       checkIsOnValidThread();
       final ByteBuffer returnedFrame = pendingBuffers.remove(timeStamp);
       if (returnedFrame == null) {
         throw new RuntimeException("unknown data buffer with time stamp "
             + timeStamp + "returned?!?");
       }
 
@@ skipping 23 matching lines @@
   }
 
   // Interface used for providing callbacks to an observer.
   interface CapturerObserver {
     // Notify if the camera have been started successfully or not.
     // Called on a Java thread owned by VideoCapturerAndroid.
     abstract void OnCapturerStarted(boolean success);
 
     // Delivers a captured frame. Called on a Java thread owned by
     // VideoCapturerAndroid.
-    abstract void OnFrameCaptured(ByteBuffer buffer, int width, int height, int rotation,
-        long timeStamp);
+    abstract void OnFrameCaptured(byte[] data, int length, int width, int height,
+        int rotation, long timeStamp);
 
     // Requests an output format from the video capturer. Captured frames
     // by the camera will be scaled/or dropped by the video capturer.
     // Called on a Java thread owned by VideoCapturerAndroid.
     abstract void OnOutputFormatRequest(int width, int height, int fps);
   }
 
   // An implementation of CapturerObserver that forwards all calls from
   // Java to the C layer.
   static class NativeObserver implements CapturerObserver {
     private final long nativeCapturer;
 
     public NativeObserver(long nativeCapturer) {
       this.nativeCapturer = nativeCapturer;
     }
 
     @Override
     public void OnCapturerStarted(boolean success) {
       nativeCapturerStarted(nativeCapturer, success);
     }
 
     @Override
-    public void OnFrameCaptured(ByteBuffer buffer, int width, int height, int rotation,
-        long timeStamp) {
-      nativeOnFrameCaptured(nativeCapturer, buffer, width, height, rotation, timeStamp);
+    public void OnFrameCaptured(byte[] data, int length, int width, int height,
+        int rotation, long timeStamp) {
+      nativeOnFrameCaptured(nativeCapturer, data, length, width, height, rotation, timeStamp);
     }
 
     @Override
     public void OnOutputFormatRequest(int width, int height, int fps) {
       nativeOnOutputFormatRequest(nativeCapturer, width, height, fps);
     }
 
     private native void nativeCapturerStarted(long nativeCapturer,
         boolean success);
     private native void nativeOnFrameCaptured(long nativeCapturer,
-        ByteBuffer buffer, int width, int height, int rotation, long timeStamp);
+        byte[] data, int length, int width, int height, int rotation, long timeStamp);
     private native void nativeOnOutputFormatRequest(long nativeCapturer,
         int width, int height, int fps);
   }
 }