| /* |
| * 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, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * 3. The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO |
| * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; |
| * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
| * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| package org.webrtc; |
| |
| import static java.lang.Math.abs; |
| import static java.lang.Math.ceil; |
| |
| import android.content.Context; |
| import android.graphics.ImageFormat; |
| import android.graphics.SurfaceTexture; |
| import android.hardware.Camera; |
| import android.hardware.Camera.PreviewCallback; |
| import android.opengl.GLES11Ext; |
| import android.opengl.GLES20; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.SystemClock; |
| import android.util.Log; |
| import android.view.Surface; |
| import android.view.WindowManager; |
| |
| import org.json.JSONArray; |
| import org.json.JSONException; |
| import org.json.JSONObject; |
| |
| import java.io.IOException; |
| import java.nio.ByteBuffer; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.concurrent.Exchanger; |
| import java.util.concurrent.TimeUnit; |
| |
| // Android specific implementation of VideoCapturer. |
| // An instance of this class can be created by an application using |
| // VideoCapturerAndroid.create(); |
| // This class extends VideoCapturer with a method to easily switch between the |
| // front and back camera. It also provides methods for enumerating valid device |
| // names. |
| // |
| // Threading notes: this class is called from C++ code, and from Camera |
| // Java callbacks. Since these calls happen on different threads, |
| // the entry points to this class are all synchronized. This shouldn't present |
| // a performance bottleneck because only onPreviewFrame() is called more than |
| // once (and is called serially on a single thread), so the lock should be |
| // uncontended. Note that each of these synchronized methods must check |
| // |camera| for null to account for having possibly waited for stopCapture() to |
| // complete. |
| @SuppressWarnings("deprecation") |
| public class VideoCapturerAndroid extends VideoCapturer implements PreviewCallback { |
| private final static String TAG = "VideoCapturerAndroid"; |
| |
| private Camera camera; // Only non-null while capturing. |
| private CameraThread cameraThread; |
| private Handler cameraThreadHandler; |
| private Context applicationContext; |
| private int id; |
| private Camera.CameraInfo info; |
| private SurfaceTexture cameraSurfaceTexture; |
| private int[] cameraGlTextures = null; |
| private final FramePool videoBuffers = new FramePool(); |
| private int width; |
| private int height; |
| private int framerate; |
| private volatile boolean pendingCameraSwitch; |
| private CapturerObserver frameObserver = null; |
| // List of formats supported by all cameras. This list is filled once in order |
| // to be able to switch cameras. |
| private static List<List<CaptureFormat>> supportedFormats; |
| |
| // Returns device names that can be used to create a new VideoCapturerAndroid. |
| public static String[] getDeviceNames() { |
| String[] names = new String[Camera.getNumberOfCameras()]; |
| for (int i = 0; i < Camera.getNumberOfCameras(); ++i) { |
| names[i] = getDeviceName(i); |
| } |
| return names; |
| } |
| |
| // Returns number of cameras on device. |
| public static int getDeviceCount() { |
| return Camera.getNumberOfCameras(); |
| } |
| |
| // Returns the name of the camera with camera index. Returns null if the |
| // camera can not be used. |
| public static String getDeviceName(int index) { |
| Camera.CameraInfo info = new Camera.CameraInfo(); |
| try { |
| Camera.getCameraInfo(index, info); |
| } catch (Exception e) { |
| Log.e(TAG, "getCameraInfo failed on index " + index,e); |
| return null; |
| } |
| |
| String facing = |
| (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) ? "front" : "back"; |
| return "Camera " + index + ", Facing " + facing |
| + ", Orientation " + info.orientation; |
| } |
| |
| // Returns the name of the front facing camera. Returns null if the |
| // camera can not be used or does not exist. |
| public static String getNameOfFrontFacingDevice() { |
| for (int i = 0; i < Camera.getNumberOfCameras(); ++i) { |
| Camera.CameraInfo info = new Camera.CameraInfo(); |
| try { |
| Camera.getCameraInfo(i, info); |
| if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) |
| return getDeviceName(i); |
| } catch (Exception e) { |
| Log.e(TAG, "getCameraInfo failed on index " + i, e); |
| } |
| } |
| return null; |
| } |
| |
| // Returns the name of the back facing camera. Returns null if the |
| // camera can not be used or does not exist. |
| public static String getNameOfBackFacingDevice() { |
| for (int i = 0; i < Camera.getNumberOfCameras(); ++i) { |
| Camera.CameraInfo info = new Camera.CameraInfo(); |
| try { |
| Camera.getCameraInfo(i, info); |
| if (info.facing == Camera.CameraInfo.CAMERA_FACING_BACK) |
| return getDeviceName(i); |
| } catch (Exception e) { |
| Log.e(TAG, "getCameraInfo failed on index " + i, e); |
| } |
| } |
| return null; |
| } |
| |
| public static VideoCapturerAndroid create(String name) { |
| VideoCapturer capturer = VideoCapturer.create(name); |
| if (capturer != null) |
| return (VideoCapturerAndroid) capturer; |
| return null; |
| } |
| |
| // Switch camera to the next valid camera id. This can only be called while |
| // the camera is running. |
| // Returns true on success. False if the next camera does not support the |
| // current resolution. |
| public synchronized boolean switchCamera(final Runnable switchDoneEvent) { |
| if (Camera.getNumberOfCameras() < 2 ) |
| return false; |
| |
| if (cameraThread == null) { |
| Log.e(TAG, "Camera has not been started"); |
| return false; |
| } |
| if (pendingCameraSwitch) { |
| // Do not handle multiple camera switch request to avoid blocking |
| // camera thread by handling too many switch request from a queue. |
| Log.w(TAG, "Ignoring camera switch request."); |
| return false; |
| } |
| |
| int new_id = (id + 1) % Camera.getNumberOfCameras(); |
| |
| CaptureFormat formatToUse = null; |
| List<CaptureFormat> formats = supportedFormats.get(new_id); |
| for (CaptureFormat format : formats) { |
| if (format.width == width && format.height == height) { |
| formatToUse = format; |
| break; |
| } |
| } |
| |
| if (formatToUse == null) { |
| Log.d(TAG, "No valid format found to switch camera."); |
| return false; |
| } |
| |
| pendingCameraSwitch = true; |
| id = new_id; |
| cameraThreadHandler.post(new Runnable() { |
| @Override public void run() { |
| switchCameraOnCameraThread(switchDoneEvent); |
| } |
| }); |
| return true; |
| } |
| |
| private VideoCapturerAndroid() { |
| Log.d(TAG, "VideoCapturerAndroid"); |
| } |
| |
| // Called by native code. |
| // Enumerates resolution and frame rates for all cameras to be able to switch |
| // cameras. Initializes local variables for the camera named |deviceName| and |
| // starts a thread to be used for capturing. |
| // If deviceName is empty, the first available device is used in order to be |
| // compatible with the generic VideoCapturer class. |
| boolean init(String deviceName) { |
| Log.d(TAG, "init " + deviceName); |
| if (deviceName == null || !initStatics()) |
| return false; |
| |
| boolean foundDevice = false; |
| if (deviceName.isEmpty()) { |
| this.id = 0; |
| foundDevice = true; |
| } else { |
| for (int i = 0; i < Camera.getNumberOfCameras(); ++i) { |
| String existing_device = getDeviceName(i); |
| if (existing_device != null && deviceName.equals(existing_device)) { |
| this.id = i; |
| foundDevice = true; |
| } |
| } |
| } |
| return foundDevice; |
| } |
| |
| private static boolean initStatics() { |
| if (supportedFormats != null) |
| return true; |
| try { |
| supportedFormats = |
| new ArrayList<List<CaptureFormat>>(Camera.getNumberOfCameras()); |
| for (int i = 0; i < Camera.getNumberOfCameras(); ++i) { |
| supportedFormats.add(getSupportedFormats(i)); |
| } |
| return true; |
| } catch (Exception e) { |
| supportedFormats = null; |
| Log.e(TAG, "InitStatics failed",e); |
| } |
| return false; |
| } |
| |
| String getSupportedFormatsAsJson() throws JSONException { |
| return getSupportedFormatsAsJson(id); |
| } |
| |
| static class CaptureFormat { |
| public final int width; |
| public final int height; |
| public final int maxFramerate; |
| public final int minFramerate; |
| |
| public CaptureFormat(int width, int height, int minFramerate, |
| int maxFramerate) { |
| this.width = width; |
| this.height = height; |
| this.minFramerate = minFramerate; |
| this.maxFramerate = maxFramerate; |
| } |
| } |
| |
| private static String getSupportedFormatsAsJson(int id) throws JSONException { |
| List<CaptureFormat> formats = supportedFormats.get(id); |
| JSONArray json_formats = new JSONArray(); |
| for (CaptureFormat format : formats) { |
| JSONObject json_format = new JSONObject(); |
| json_format.put("width", format.width); |
| json_format.put("height", format.height); |
| json_format.put("framerate", (format.maxFramerate + 999) / 1000); |
| json_formats.put(json_format); |
| } |
| Log.d(TAG, "Supported formats for camera " + id + ": " |
| + json_formats.toString(2)); |
| return json_formats.toString(); |
| } |
| |
| // Returns a list of CaptureFormat for the camera with index id. |
| static ArrayList<CaptureFormat> getSupportedFormats(int id) { |
| ArrayList<CaptureFormat> formatList = new ArrayList<CaptureFormat>(); |
| |
| Camera camera; |
| try { |
| camera = Camera.open(id); |
| } catch (Exception e) { |
| Log.e(TAG, "Open camera failed on id " + id, e); |
| return formatList; |
| } |
| |
| try { |
| Camera.Parameters parameters; |
| parameters = camera.getParameters(); |
| // getSupportedPreviewFpsRange returns a sorted list. |
| List<int[]> listFpsRange = parameters.getSupportedPreviewFpsRange(); |
| int[] range = {0, 0}; |
| if (listFpsRange != null) |
| range = listFpsRange.get(listFpsRange.size() -1); |
| |
| List<Camera.Size> supportedSizes = parameters.getSupportedPreviewSizes(); |
| for (Camera.Size size : supportedSizes) { |
| formatList.add(new CaptureFormat(size.width, size.height, |
| range[Camera.Parameters.PREVIEW_FPS_MIN_INDEX], |
| range[Camera.Parameters.PREVIEW_FPS_MAX_INDEX])); |
| } |
| camera.release(); |
| } catch (Exception e) { |
| Log.e(TAG, "getSupportedFormats failed on id " + id, e); |
| } |
| return formatList; |
| } |
| |
| private class CameraThread extends Thread { |
| private Exchanger<Handler> handlerExchanger; |
| public CameraThread(Exchanger<Handler> handlerExchanger) { |
| this.handlerExchanger = handlerExchanger; |
| } |
| |
| @Override public void run() { |
| Looper.prepare(); |
| exchange(handlerExchanger, new Handler()); |
| Looper.loop(); |
| } |
| } |
| |
| // Called by native code. Returns true if capturer is started. |
| // |
| // Note that this actually opens the camera, and Camera callbacks run on the |
| // thread that calls open(), so this is done on the CameraThread. Since the |
| // API needs a synchronous success return value we wait for the result. |
| synchronized void startCapture( |
| final int width, final int height, final int framerate, |
| final Context applicationContext, final CapturerObserver frameObserver) { |
| Log.d(TAG, "startCapture requested: " + width + "x" + height |
| + "@" + framerate); |
| if (applicationContext == null) { |
| throw new RuntimeException("applicationContext not set."); |
| } |
| if (frameObserver == null) { |
| throw new RuntimeException("frameObserver not set."); |
| } |
| if (width % 16 != 0) { |
| throw new RuntimeException("width must be a multiple of 16." ); |
| } |
| if (cameraThreadHandler != null) { |
| throw new RuntimeException("Camera has already been started."); |
| } |
| this.width = width; |
| this.height = height; |
| this.framerate = framerate; |
| |
| Exchanger<Handler> handlerExchanger = new Exchanger<Handler>(); |
| cameraThread = new CameraThread(handlerExchanger); |
| cameraThread.start(); |
| cameraThreadHandler = exchange(handlerExchanger, null); |
| cameraThreadHandler.post(new Runnable() { |
| @Override public void run() { |
| startCaptureOnCameraThread(width, height, framerate, frameObserver, |
| applicationContext); |
| } |
| }); |
| } |
| |
| private void startCaptureOnCameraThread( |
| int width, int height, int framerate, CapturerObserver frameObserver, |
| Context applicationContext) { |
| Throwable error = null; |
| this.applicationContext = applicationContext; |
| this.frameObserver = frameObserver; |
| try { |
| this.camera = Camera.open(id); |
| this.info = new Camera.CameraInfo(); |
| Camera.getCameraInfo(id, info); |
| // No local renderer (we only care about onPreviewFrame() buffers, not a |
| // directly-displayed UI element). Camera won't capture without |
| // setPreview{Texture,Display}, so we create a SurfaceTexture and hand |
| // it over to Camera, but never listen for frame-ready callbacks, |
| // and never call updateTexImage on it. |
| try { |
| cameraSurfaceTexture = null; |
| |
| cameraGlTextures = new int[1]; |
| // Generate one texture pointer and bind it as an external texture. |
| GLES20.glGenTextures(1, cameraGlTextures, 0); |
| GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, |
| cameraGlTextures[0]); |
| GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, |
| GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR); |
| GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, |
| GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR); |
| GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, |
| GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE); |
| GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, |
| GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE); |
| |
| cameraSurfaceTexture = new SurfaceTexture(cameraGlTextures[0]); |
| cameraSurfaceTexture.setOnFrameAvailableListener(null); |
| |
| camera.setPreviewTexture(cameraSurfaceTexture); |
| } catch (IOException e) { |
| throw new RuntimeException(e); |
| } |
| |
| Log.d(TAG, "Camera orientation: " + info.orientation + |
| " .Device orientation: " + getDeviceOrientation()); |
| Camera.Parameters parameters = camera.getParameters(); |
| Log.d(TAG, "isVideoStabilizationSupported: " + |
| parameters.isVideoStabilizationSupported()); |
| if (parameters.isVideoStabilizationSupported()) { |
| parameters.setVideoStabilization(true); |
| } |
| |
| int androidFramerate = framerate * 1000; |
| int[] range = getFramerateRange(parameters, androidFramerate); |
| if (range != null) { |
| Log.d(TAG, "Start capturing: " + width + "x" + height + "@[" + |
| range[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] + ":" + |
| range[Camera.Parameters.PREVIEW_FPS_MAX_INDEX] + "]"); |
| parameters.setPreviewFpsRange( |
| range[Camera.Parameters.PREVIEW_FPS_MIN_INDEX], |
| range[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]); |
| } |
| Camera.Size pictureSize = getPictureSize(parameters, width, height); |
| parameters.setPictureSize(pictureSize.width, pictureSize.height); |
| parameters.setPreviewSize(width, height); |
| int format = ImageFormat.YV12; |
| parameters.setPreviewFormat(format); |
| camera.setParameters(parameters); |
| // Note: setRecordingHint(true) actually decrease frame rate on N5. |
| // parameters.setRecordingHint(true); |
| |
| videoBuffers.queueCameraBuffers(width, height, format, camera); |
| camera.setPreviewCallbackWithBuffer(this); |
| camera.startPreview(); |
| frameObserver.OnCapturerStarted(true); |
| return; |
| } catch (RuntimeException e) { |
| error = e; |
| } |
| Log.e(TAG, "startCapture failed", error); |
| if (camera != null) { |
| stopCaptureOnCameraThread(); |
| } |
| frameObserver.OnCapturerStarted(false); |
| return; |
| } |
| |
| // Called by native code. Returns true when camera is known to be stopped. |
| synchronized void stopCapture() throws InterruptedException { |
| if (cameraThreadHandler == null) { |
| throw new RuntimeException("Calling stopCapture() for already stopped camera."); |
| } |
| Log.d(TAG, "stopCapture"); |
| cameraThreadHandler.post(new Runnable() { |
| @Override public void run() { |
| stopCaptureOnCameraThread(); |
| } |
| }); |
| cameraThread.join(); |
| cameraThreadHandler = null; |
| Log.d(TAG, "stopCapture done"); |
| } |
| |
| private void stopCaptureOnCameraThread() { |
| Log.d(TAG, "stopCaptureOnCameraThread"); |
| doStopCaptureOnCamerathread(); |
| Looper.myLooper().quit(); |
| return; |
| } |
| |
| private void doStopCaptureOnCamerathread() { |
| try { |
| camera.stopPreview(); |
| camera.setPreviewCallbackWithBuffer(null); |
| videoBuffers.stopReturnBuffersToCamera(); |
| |
| camera.setPreviewTexture(null); |
| cameraSurfaceTexture = null; |
| if (cameraGlTextures != null) { |
| GLES20.glDeleteTextures(1, cameraGlTextures, 0); |
| cameraGlTextures = null; |
| } |
| |
| camera.release(); |
| camera = null; |
| } catch (IOException e) { |
| Log.e(TAG, "Failed to stop camera", e); |
| } |
| } |
| |
| private void switchCameraOnCameraThread(Runnable switchDoneEvent) { |
| Log.d(TAG, "switchCameraOnCameraThread"); |
| |
| doStopCaptureOnCamerathread(); |
| startCaptureOnCameraThread(width, height, framerate, frameObserver, |
| applicationContext); |
| pendingCameraSwitch = false; |
| Log.d(TAG, "switchCameraOnCameraThread done"); |
| if (switchDoneEvent != null) { |
| switchDoneEvent.run(); |
| } |
| } |
| |
| 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); |
| } |
| }); |
| } |
| |
| private int getDeviceOrientation() { |
| int orientation = 0; |
| |
| WindowManager wm = (WindowManager) applicationContext.getSystemService( |
| Context.WINDOW_SERVICE); |
| switch(wm.getDefaultDisplay().getRotation()) { |
| case Surface.ROTATION_90: |
| orientation = 90; |
| break; |
| case Surface.ROTATION_180: |
| orientation = 180; |
| break; |
| case Surface.ROTATION_270: |
| orientation = 270; |
| break; |
| case Surface.ROTATION_0: |
| default: |
| orientation = 0; |
| break; |
| } |
| return orientation; |
| } |
| |
| private static int[] getFramerateRange(Camera.Parameters parameters, |
| int framerate) { |
| List<int[]> listFpsRange = parameters.getSupportedPreviewFpsRange(); |
| int[] bestRange = null; |
| int bestRangeDiff = Integer.MAX_VALUE; |
| for (int[] range : listFpsRange) { |
| int rangeDiff = |
| abs(framerate -range[Camera.Parameters.PREVIEW_FPS_MIN_INDEX]) |
| + abs(range[Camera.Parameters.PREVIEW_FPS_MAX_INDEX] - framerate); |
| if (bestRangeDiff > rangeDiff) { |
| bestRange = range; |
| bestRangeDiff = rangeDiff; |
| } |
| } |
| return bestRange; |
| } |
| |
| private static Camera.Size getPictureSize(Camera.Parameters parameters, |
| int width, int height) { |
| int bestAreaDiff = Integer.MAX_VALUE; |
| Camera.Size bestSize = null; |
| int requestedArea = width * height; |
| for (Camera.Size pictureSize : parameters.getSupportedPictureSizes()) { |
| int areaDiff = abs(requestedArea |
| - pictureSize.width * pictureSize.height); |
| if (areaDiff < bestAreaDiff) { |
| bestAreaDiff = areaDiff; |
| bestSize = pictureSize; |
| } |
| } |
| return bestSize; |
| } |
| |
| // Called on cameraThread so must not "synchronized". |
| @Override |
| public void onPreviewFrame(byte[] data, Camera callbackCamera) { |
| if (Thread.currentThread() != cameraThread) { |
| throw new RuntimeException("Camera callback not on camera thread?!?"); |
| } |
| if (camera == null) { |
| return; |
| } |
| if (camera != callbackCamera) { |
| throw new RuntimeException("Unexpected camera in callback!"); |
| } |
| |
| long captureTimeNs = |
| TimeUnit.MILLISECONDS.toNanos(SystemClock.elapsedRealtime()); |
| |
| 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. |
| // Note that since data is directBuffer, |
| // data.length >= videoBuffers.frameSize. |
| videoBuffers.reserveByteBuffer(data, captureTimeNs); |
| frameObserver.OnFrameCaptured(data, videoBuffers.frameSize, rotation, |
| captureTimeNs); |
| } |
| |
| // runCameraThreadUntilIdle make sure all posted messages to the cameraThread |
| // is processed before returning. It does that by itself posting a message to |
| // to the message queue and waits until is has been processed. |
| // It is used in tests. |
| void runCameraThreadUntilIdle() { |
| if (cameraThreadHandler == null) |
| return; |
| final Exchanger<Boolean> result = new Exchanger<Boolean>(); |
| cameraThreadHandler.post(new Runnable() { |
| @Override public void run() { |
| exchange(result, true); // |true| is a dummy here. |
| } |
| }); |
| exchange(result, false); // |false| is a dummy value here. |
| return; |
| } |
| |
| // Exchanges |value| with |exchanger|, converting InterruptedExceptions to |
| // 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. |
| 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 int numCaptureBuffers = 3; |
| private final List<Frame> cameraFrames = new ArrayList<Frame>(); |
| public int frameSize = 0; |
| private Camera camera; |
| |
| private static class Frame { |
| private final ByteBuffer buffer; |
| public long timeStamp = -1; |
| public final int frameSize; |
| |
| Frame(int frameSize) { |
| this.frameSize = frameSize; |
| buffer = ByteBuffer.allocateDirect(frameSize); |
| } |
| |
| byte[] data() { |
| return buffer.array(); |
| } |
| } |
| |
| // Adds frames as callback buffers to |camera|. If a new frame size is |
| // required, new buffers are allocated and added. |
| void queueCameraBuffers(int width, int height, int format, Camera camera) { |
| if (this.camera != null) |
| throw new RuntimeException("camera already set."); |
| |
| this.camera = camera; |
| int newframeSize = 0; |
| if (format == ImageFormat.YV12) { |
| int yStride = (int) ceil(width / 16.0) * 16; |
| int uvStride = (int) ceil( (yStride / 2) / 16.0) * 16; |
| int ySize = yStride * height; |
| int uvSize = uvStride * height / 2; |
| newframeSize = ySize + uvSize * 2; |
| } else { |
| newframeSize = |
| width * height * ImageFormat.getBitsPerPixel(format) / 8; |
| } |
| |
| int numberOfEnquedCameraBuffers = 0; |
| if (newframeSize != frameSize) { |
| // Create new frames and add to the camera. |
| // The old frames will be released when frames are returned. |
| for (int i = 0; i < numCaptureBuffers; ++i) { |
| Frame frame = new Frame(newframeSize); |
| cameraFrames.add(frame); |
| this.camera.addCallbackBuffer(frame.data()); |
| } |
| numberOfEnquedCameraBuffers = numCaptureBuffers; |
| } else { |
| // Add all frames that have been returned. |
| for (Frame frame : cameraFrames) { |
| if (frame.timeStamp < 0) { |
| camera.addCallbackBuffer(frame.data()); |
| ++numberOfEnquedCameraBuffers; |
| } |
| } |
| } |
| frameSize = newframeSize; |
| Log.d(TAG, "queueCameraBuffers enqued " + numberOfEnquedCameraBuffers |
| + " buffers of size " + frameSize + "."); |
| } |
| |
| void stopReturnBuffersToCamera() { |
| this.camera = null; |
| String pendingTimeStamps = new String(); |
| for (Frame frame : cameraFrames) { |
| if (frame.timeStamp > -1) { |
| pendingTimeStamps+= " " + frame.timeStamp; |
| } |
| } |
| Log.d(TAG, "stopReturnBuffersToCamera called." |
| + (pendingTimeStamps.isEmpty() ? |
| " All buffers have been returned." |
| : " Pending buffers " + pendingTimeStamps + ".")); |
| |
| } |
| |
| void reserveByteBuffer(byte[] data, long timeStamp) { |
| for (Frame frame : cameraFrames) { |
| if (data == frame.data()) { |
| if (frame.timeStamp > 0) { |
| throw new RuntimeException("Frame already in use !"); |
| } |
| frame.timeStamp = timeStamp; |
| return; |
| } |
| } |
| throw new RuntimeException("unknown data buffer?!?"); |
| } |
| |
| void returnBuffer(long timeStamp) { |
| Frame returnedFrame = null; |
| for (Frame frame : cameraFrames) { |
| if (timeStamp == frame.timeStamp) { |
| frame.timeStamp = -1; |
| returnedFrame = frame; |
| break; |
| } |
| } |
| |
| if (returnedFrame == null) { |
| throw new RuntimeException("unknown data buffer with time stamp " |
| + timeStamp + "returned?!?"); |
| } |
| |
| if (camera != null && returnedFrame.frameSize == frameSize) { |
| camera.addCallbackBuffer(returnedFrame.data()); |
| return; |
| } |
| |
| if (returnedFrame.frameSize != frameSize) { |
| Log.d(TAG, "returnBuffer with time stamp "+ timeStamp |
| + " called with old frame size, " + returnedFrame.frameSize + "."); |
| // Since this frame has the wrong size, remove it from the list. Frames |
| // with the correct size is created in queueCameraBuffers so this must |
| // be an old buffer. |
| cameraFrames.remove(returnedFrame); |
| return; |
| } |
| |
| Log.d(TAG, "returnBuffer with time stamp "+ timeStamp |
| + " called after camera has been stopped."); |
| } |
| } |
| |
| // 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(byte[] data, int length, int rotation, |
| long timeStamp); |
| } |
| |
| // 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(byte[] data, int length, int rotation, |
| long timeStamp) { |
| nativeOnFrameCaptured(nativeCapturer, data, length, rotation, timeStamp); |
| } |
| |
| private native void nativeCapturerStarted(long nativeCapturer, |
| boolean success); |
| private native void nativeOnFrameCaptured(long nativeCapturer, |
| byte[] data, int length, int rotation, long timeStamp); |
| } |
| } |
