AndroidVideoCapturerJni: Fix threading issues

talk/app/webrtc/java/src/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 702 matching lines @@
   private void onOutputFormatRequestOnCameraThread(
       int width, int height, int fps) {
     if (camera == null) {
       return;
     }
     Log.d(TAG, "onOutputFormatRequestOnCameraThread: " + width + "x" + height +
         "@" + fps);
     frameObserver.OnOutputFormatRequest(width, height, fps);
   }
 
-  synchronized void returnBuffer(final long timeStamp) {
-    if (cameraThreadHandler == null) {
-      // The camera has been stopped.
-      videoBuffers.returnBuffer(timeStamp);
-      return;
-    }
-    cameraThreadHandler.post(new Runnable() {
-      @Override public void run() {
-        videoBuffers.returnBuffer(timeStamp);
-      }
-    });
+  void returnBuffer(long timeStamp) {
+    videoBuffers.returnBuffer(timeStamp);
   }
 
   private int getDeviceOrientation() {
     int orientation = 0;
 
     WindowManager wm = (WindowManager) applicationContext.getSystemService(
         Context.WINDOW_SERVICE);
     switch(wm.getDefaultDisplay().getRotation()) {
       case Surface.ROTATION_90:
         orientation = 90;
@@ skipping 103 matching lines @@
   // RuntimeExceptions (since we expect never to see these).
   private static <T> T exchange(Exchanger<T> exchanger, T value) {
     try {
       return exchanger.exchange(value);
     } catch (InterruptedException e) {
       throw new RuntimeException(e);
     }
   }
 
   // Class used for allocating and bookkeeping video frames. All buffers are
-  // direct allocated so that they can be directly used from native code.
+  // direct allocated so that they can be directly used from native code. This class is
+  // synchronized and can be called from multiple threads.
   private static class FramePool {
     // Arbitrary queue depth.  Higher number means more memory allocated & held,
     // lower number means more sensitivity to processing time in the client (and
     // potentially stalling the capturer if it runs out of buffers to write to).
     private static final int numCaptureBuffers = 3;
     // This container tracks the buffers added as camera callback buffers. It is needed for finding
     // the corresponding ByteBuffer given a byte[].
     private final Map<byte[], ByteBuffer> queuedBuffers = new IdentityHashMap<byte[], ByteBuffer>();
     // This container tracks the frames that have been sent but not returned. It is needed for
     // keeping the buffers alive and for finding the corresponding ByteBuffer given a timestamp.
     private final Map<Long, ByteBuffer> pendingBuffers = new HashMap<Long, ByteBuffer>();
     private int frameSize = 0;
     private Camera camera;
 
-    int numCaptureBuffersAvailable() {
+    synchronized int numCaptureBuffersAvailable() {
       return queuedBuffers.size();
     }
 
     // Discards previous queued buffers and adds new callback buffers to camera.
-    void queueCameraBuffers(int frameSize, Camera camera) {
+    synchronized void queueCameraBuffers(int frameSize, Camera camera) {
       this.camera = camera;
       this.frameSize = frameSize;
 
       queuedBuffers.clear();
       for (int i = 0; i < numCaptureBuffers; ++i) {
         final ByteBuffer buffer = ByteBuffer.allocateDirect(frameSize);
         camera.addCallbackBuffer(buffer.array());
         queuedBuffers.put(buffer.array(), buffer);
       }
       Log.d(TAG, "queueCameraBuffers enqueued " + numCaptureBuffers
           + " buffers of size " + frameSize + ".");
     }
 
-    String pendingFramesTimeStamps() {
+    synchronized String pendingFramesTimeStamps() {
       List<Long> timeStampsMs = new ArrayList<Long>();
       for (Long timeStampNs : pendingBuffers.keySet()) {
         timeStampsMs.add(TimeUnit.NANOSECONDS.toMillis(timeStampNs));
       }
       return timeStampsMs.toString();
     }
 
-    void stopReturnBuffersToCamera() {
+    synchronized void stopReturnBuffersToCamera() {
       this.camera = null;
       queuedBuffers.clear();
       // Frames in |pendingBuffers| need to be kept alive until they are returned.
       Log.d(TAG, "stopReturnBuffersToCamera called."
             + (pendingBuffers.isEmpty() ?
                    " All buffers have been returned."
                    : " Pending buffers: " + pendingFramesTimeStamps() + "."));
     }
 
-    boolean reserveByteBuffer(byte[] data, long timeStamp) {
+    synchronized boolean reserveByteBuffer(byte[] data, long timeStamp) {
       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.
         Log.w(TAG, "Received callback buffer from previous configuration with length: "
             + (data == null ? "null" : data.length));
         return false;
       }
       if (buffer.capacity() != frameSize) {
         throw new IllegalStateException("Callback buffer has unexpected frame size");
       }
       if (pendingBuffers.containsKey(timeStamp)) {
         Log.e(TAG, "Timestamp already present in pending buffers - they need to be unique");
         return false;
       }
       pendingBuffers.put(timeStamp, buffer);
       if (queuedBuffers.isEmpty()) {
         Log.v(TAG, "Camera is running out of capture buffers."
             + " Pending buffers: " + pendingFramesTimeStamps());
       }
       return true;
     }
 
-    void returnBuffer(long timeStamp) {
+    synchronized void returnBuffer(long timeStamp) {
       final ByteBuffer returnedFrame = pendingBuffers.remove(timeStamp);
       if (returnedFrame == null) {
         throw new RuntimeException("unknown data buffer with time stamp "
             + timeStamp + "returned?!?");
       }
 
       if (camera != null && returnedFrame.capacity() == frameSize) {
         camera.addCallbackBuffer(returnedFrame.array());
         if (queuedBuffers.isEmpty()) {
           Log.v(TAG, "Frame returned when camera is running out of capture"
@@ skipping 61 matching lines @@
     }
 
     private native void nativeCapturerStarted(long nativeCapturer,
         boolean success);
     private native void nativeOnFrameCaptured(long nativeCapturer,
         byte[] data, int length, int width, int height, int rotation, long timeStamp);
     private native void nativeOnOutputFormatRequest(long nativeCapturer,
         int width, int height, int fps);
   }
 }