mCameraPublishStateLD;
+
+ private int mCameraDeviceError = ERROR_NONE;
+
+ private CameraState mCameraPublishState;
+
+ private final Camera2Control mControl;
+
+ private ICameraErrorListener mErrorListener;
+
+ //这个东西可能持有外部很多窗口,导致泄漏！！！ 小心，尤其是里面的callback
+ private SessionConfig mSessionConfig;
+
+ private final CameraStateCallback mStateCallback;
+
+
+ @NonNull
+ private final CameraReopenMonitor mCameraReopenMonitor = new CameraReopenMonitor();
+
+
+ enum InternalState {
+ /**
+ * Stable state once the camera has been constructed.
+ *
+ * At this state the {@link CameraDevice} should be invalid, but threads should be still
+ * in a valid state. Whenever a camera device is fully closed the camera should return to
+ * this state.
+ *
+ *
After an error occurs the camera returns to this state so that the device can be
+ * cleanly reopened.
+ */
+ INITIALIZED,
+ /**
+ * Camera is waiting for the camera to be available to open.
+ *
+ *
A camera may enter a pending state if the camera has been stolen by another process
+ * or if the maximum number of available cameras is already open.
+ *
+ *
At the end of this state, the camera should move into the OPENING state.
+ */
+ PENDING_OPEN,
+ /**
+ * A transitional state where the camera device is currently opening.
+ *
+ *
At the end of this state, the camera should move into either the OPENED or CLOSING
+ * state.
+ */
+ OPENING,
+ /**
+ * A stable state where the camera has been opened.
+ *
+ *
During this state the camera device should be valid. It is at this time a valid
+ * capture session can be active. Capture requests should be issued during this state only.
+ */
+ OPENED,
+ /**
+ * A transitional state where the camera device is currently closing.
+ *
+ *
At the end of this state, the camera should move into the INITIALIZED state.
+ */
+ CLOSING,
+ /**
+ * A transitional state where the camera was previously closing, but not fully closed before
+ * a call to open was made.
+ *
+ *
At the end of this state, the camera should move into one of two states. The OPENING
+ * state if the device becomes fully closed, since it must restart the process of opening a
+ * camera. The OPENED state if the device becomes opened, which can occur if a call to close
+ * had been done during the OPENING state.
+ */
+ REOPENING,
+ /**
+ * A transitional state where the camera will be closing permanently.
+ *
+ *
At the end of this state, the camera should move into the RELEASED state.
+ */
+ @Deprecated
+ RELEASING,
+ /**
+ * A stable state where the camera has been permanently closed.
+ *
+ *
During this state all resources should be released and all operations on the camera
+ * will do nothing.
+ */
+ @Deprecated
+ RELEASED
+ }
+
+
+ private final CameraManager mCameraManager;
+ private final CameraAbilityCallback mCameraAbilityCallback;
+
+ private SyncCaptureSession mCaptureSession;
+
+ public Camera2CameraImpl(CameraManager cameraManager, String cameraId, Executor executor, Handler handler) {
+ mExecutor = executor;
+ mHandler = handler;
+ mCameraManager = cameraManager;
+ mCameraId = cameraId;
+ mCameraAbilityCallback = new CameraAbilityCallback();
+ mCameraManager.registerAvailabilityCallback(mCameraAbilityCallback, handler);
+ mCamera2Info = new Camera2Info(cameraId);
+ mStateCallback = new CameraStateCallback(new HandlerScheduledExecutorService(mHandler));
+ mCameraPublishStateLD = new MutableLiveData<>();
+ mControl = new Camera2Control(this);
+ mErrorListener = new ComboCameraErrorListener(null);
+
+ }
+
+
+ private class CameraAbilityCallback extends CameraManager.AvailabilityCallback {
+
+ private boolean mIsAvailable = true;
+
+ @Override
+ public void onCameraAvailable(@NonNull String cameraId) {
+ if (!TextUtils.equals(cameraId, mCameraId)) {
+ return;
+ }
+
+ CameraLogger.i(TAG, "Camera2.onCameraAvailable %s", cameraId);
+
+ mIsAvailable = true;
+
+ if (mState == InternalState.PENDING_OPEN) {
+ openCameraDevices(false);
+ }
+ }
+
+ public boolean isAvailable() {
+ return mIsAvailable;
+ }
+
+ @Override
+ public void onCameraUnavailable(@NonNull String cameraId) {
+ if (!TextUtils.equals(cameraId, mCameraId)) {
+ return;
+ }
+ CameraLogger.e(TAG, "Camera2.onCameraUnavailable %s", cameraId);
+
+
+ //我就是要最高权限
+ mIsAvailable = false;
+
+ if (mState == InternalState.PENDING_OPEN) {
+ //TODO 确定是否需要触发一下相机的关闭
+ //TODO 要添加一下统计，看看多少场景下，一开始相机是不可用的
+ }
+ }
+ }
+
+ public void updateSessionConfig(SessionConfig sessionConfig) {
+ mExecutor.execute(() -> {
+ mSessionConfig = sessionConfig;
+ mErrorListener = new ComboCameraErrorListener(Collections.singletonList(mSessionConfig.getCameraErrorListener()));
+ });
+
+ }
+
+ public static final int ERROR_NONE = 0;
+
+ private class CameraStateCallback extends CameraDevice.StateCallback {
+
+
+ private ScheduledReopen mScheduledReopenRunnable;
+ @SuppressWarnings("WeakerAccess") // synthetic accessor
+ ScheduledFuture mScheduledReopenHandle;
+
+ private final HandlerScheduledExecutorService mScheduler;
+
+
+ public CameraStateCallback(HandlerScheduledExecutorService scheduler) {
+ mScheduler = scheduler;
+ }
+
+ @Override
+ public void onOpened(@NonNull CameraDevice camera) {
+ CameraLogger.i(TAG, "CameraDevice.onOpen when %s ", mState);
+ //This is called when the camera is open
+ mCameraDeviceError = ERROR_NONE;
+ mCameraDevice = camera;
+ switch (mState) {
+ case OPENING:
+ case REOPENING:
+ setState(InternalState.OPENED);
+ mCaptureSession = new SyncCaptureSession(Camera2CameraImpl.this, mHandler);
+ mCaptureSession.open(camera, mSessionConfig);
+ break;
+ case RELEASING:
+ case CLOSING:
+ mCameraDevice.close();
+ mCameraDevice = null;
+ break;
+ default:
+ throw new IllegalStateException(
+ "onOpened() should not be possible from state: " + mState);
+ }
+
+ }
+
+ @Override
+ public void onDisconnected(@NonNull CameraDevice camera) {
+ CameraLogger.e(TAG, "CameraDevice.onDisconnected() " + mState);
+
+ // Can be treated the same as camera in use beca`use in both situations the
+ // CameraDevice needs to be closed before it can be safely reopened and used.
+ onError(camera, CameraDevice.StateCallback.ERROR_CAMERA_IN_USE);
+ }
+
+ @Override
+ public void onError(@NonNull CameraDevice camera, int error) {
+ CameraLogger.e(TAG, "CameraDevice.onError( %s ) when %s ", CameraLogger.getCameraErrorMessage(error), mState);
+
+ onErrorInternal(camera, error);
+
+ mErrorListener.onError(error, CameraLogger.getCameraErrorMessage(error));
+
+ }
+
+
+ @Override
+ public void onClosed(@NonNull CameraDevice camera) {
+ CameraLogger.i(TAG, "CameraDevice.onClosed");
+ switch (mState) {
+ case CLOSING:
+ case RELEASING:
+ finishClose();
+ break;
+ case REOPENING:
+ if (mCameraDeviceError == ERROR_NONE) {
+ openCameraDevices(false);
+ } else {
+ CameraLogger.e("Camera closed due to error: %s", CameraLogger.getCameraErrorMessage(mCameraDeviceError));
+ scheduleCameraReopen();
+ }
+ break;
+ }
+ }
+
+ /**
+ * Resets the camera reopen attempts monitor. This should be called when the camera open is
+ * not triggered by a scheduled camera reopen, but rather by an explicit request.
+ */
+ @ExecutedBy("mExecutor")
+ void resetReopenMonitor() {
+ mCameraReopenMonitor.reset();
+ }
+
+
+ // Delay long enough to guarantee the app could have been backgrounded.
+ // See ProcessLifecycleProvider for where this delay comes from.
+ static final int REOPEN_DELAY_MS = 700;
+
+ @ExecutedBy("mExecutor")
+ boolean scheduleCameraReopen() {
+ Preconditions.checkState(mScheduledReopenRunnable == null);
+ Preconditions.checkState(mScheduledReopenHandle == null);
+
+ if (mCameraReopenMonitor.canScheduleCameraReopen()) {
+ mScheduledReopenRunnable = new ScheduledReopen(mExecutor);
+ CameraLogger.i(TAG, "Attempting camera re-open in %dms: %s", REOPEN_DELAY_MS, mScheduledReopenRunnable);
+ mScheduledReopenHandle = mScheduler.schedule(mScheduledReopenRunnable, REOPEN_DELAY_MS);
+ return true;
+ } else {
+ CameraLogger.e(TAG,
+ "Camera reopening attempted for "
+ + CameraReopenMonitor.REOPEN_LIMIT_MS
+ + "ms without success.");
+ setState(InternalState.INITIALIZED);
+
+
+ mErrorListener.onError(CameraLogger.ERROR_TRY_REOPEN_ERROR,
+ CameraLogger.getCameraErrorMessage(CameraLogger.ERROR_TRY_REOPEN_ERROR) + ":" + CameraLogger.getCameraErrorMessage(mCameraDeviceError));
+ }
+ return false;
+ }
+
+ /**
+ * Attempts to cancel reopen.
+ *
+ *
If successful, it is safe to finish closing the camera via {@link #finishClose()} as
+ * a reopen will only be scheduled after {@link #onClosed(CameraDevice)} has been called.
+ *
+ * @return true if reopen was cancelled. False if no re-open was scheduled.
+ */
+ @ExecutedBy("mExecutor")
+ boolean cancelScheduledReopen() {
+ boolean cancelled = false;
+ if (mScheduledReopenHandle != null) {
+ // A reopen has been scheduled
+ CameraLogger.i(TAG, "Cancelling scheduled re-open: " + mScheduledReopenRunnable);
+
+ // Ensure the runnable doesn't try to open the camera if it has already
+ // been pushed to the executor.
+ mScheduledReopenRunnable.cancel();
+ mScheduledReopenRunnable = null;
+
+ // Un-schedule the runnable in case if hasn't run.
+ mScheduledReopenHandle.cancel(/*mayInterruptIfRunning=*/false);
+ mScheduledReopenHandle = null;
+
+ cancelled = true;
+ }
+
+ return cancelled;
+ }
+
+
+ }
+
+
+ // Should only be called once the camera device is actually closed.
+ @ExecutedBy("mExecutor")
+ private void finishClose() {
+ Preconditions.checkState(mState == InternalState.RELEASING || mState == InternalState.CLOSING);
+ mCameraDevice = null;
+
+ if (mState == InternalState.CLOSING) {
+ if (mCaptureSession != null) {
+ mCaptureSession.forceRelease();
+ mCaptureSession = null;
+ }
+ mSessionConfig = null;
+ setState(InternalState.INITIALIZED);
+ } else {
+ // After a camera is released, it cannot be reopened, so we don't need to listen for
+ // available camera changes.
+ mCameraManager.unregisterAvailabilityCallback(mCameraAbilityCallback);
+
+ setState(InternalState.RELEASED);
+ }
+ }
+
+
+ public void open() {
+ mExecutor.execute(this::openInternal);
+ }
+
+
+ @ExecutedBy("mExecutor")
+ private void openInternal() {
+ Preconditions.cameraThreadCheck();
+
+
+ switch (mState) {
+ case INITIALIZED:
+ openCameraDevices(false);
+ break;
+ case CLOSING:
+ setState(InternalState.REOPENING);
+ break;
+ }
+ }
+
+ @SuppressLint("MissingPermission")
+ private void openCameraDevices(boolean fromScheduledCameraReopen) {
+ Preconditions.cameraThreadCheck();
+
+ if (!fromScheduledCameraReopen) {
+ mStateCallback.resetReopenMonitor();
+ }
+ mStateCallback.cancelScheduledReopen();
+
+
+ /**
+ * As of API level 23, devices for which the AvailabilityCallback#onCameraUnavailable(String) callback has been called due to the device being in use by a lower-priority, background camera API client can still potentially be opened by calling this method when the calling camera API client has a higher priority than the current camera API client using this device.
+ * In general, if the top, foreground activity is running within your application process, your process will be given the highest priority when accessing the camera, and this method will succeed even if the camera device is in use by another camera API client.
+ * Any lower-priority application that loses control of the camera in this way will receive an CameraDevice.StateCallback.onDisconnected(CameraDevice) callback.
+ * Opening the same camera ID twice in the same application will similarly cause the CameraDevice.StateCallback.onDisconnected(CameraDevice) callback being fired for the CameraDevice from the first open call and all ongoing tasks being droppped.
+ */
+ //By Design : false && mCameraAbilityCallback.isAvailable()
+ if (false && !mCameraAbilityCallback.isAvailable()) {
+ setState(InternalState.PENDING_OPEN);
+ CameraLogger.e(TAG, "camera (%s) is inability", mCameraId);
+ return;
+ }
+
+ setState(InternalState.OPENING);
+
+ try {
+ mCameraManager.openCamera(mCameraId, mStateCallback, mHandler);
+ } catch (CameraAccessException e) {
+ // Camera2 will call the onError() callback with the specific error code that
+ // caused this failure. No need to do anything here.
+ CameraLogger.e(TAG, "open camera error (CameraAccessException) %s ", e.getMessage());
+ } catch (IllegalArgumentException e) {
+ CameraLogger.e(TAG, "open camera error %s ", e.getMessage());
+ String errorMessage = e.getMessage();
+ /**
+ * In the process of a error restart, the camera hardware did not recover so quickly
+ * On Mi8 Android 11 ，devices will throws IllegalArgumentException(SupportCameraApi) when check
+ * SupportCameraApi error rather than callback onError. This causes us to have only one
+ * restart opportunity to take
+ * effect.But this devices need 5s+ to recover.
+ *
+ * see https://cs.android.com/android/platform/superproject/+/master:frameworks/av/services/camera/libcameraservice/CameraService.cpp;drc=master;bpv=0;bpt=1;l=2324?hl=zh-cn
+ */
+ if (errorMessage != null
+ && errorMessage.contains("supportsCameraApi")
+ && errorMessage.contains("Unknown camera ID")
+ && mCameraDeviceError != ERROR_NONE) {
+ if (mStateCallback.scheduleCameraReopen()) {
+ setState(InternalState.REOPENING);
+ } else {
+ setState(InternalState.INITIALIZED);
+ }
+ } else {
+ //Camera has not been open
+ setState(InternalState.INITIALIZED);
+ }
+ } catch (Exception e) {
+ CameraLogger.e(TAG, "open camera error %s ", e.getMessage());
+ //Camera has not been open
+ setState(InternalState.INITIALIZED);
+ }
+ }
+
+
+ private void setState(InternalState state) {
+ CameraState publicState;
+ switch (state) {
+ case INITIALIZED:
+ publicState = CameraState.CLOSED;
+ break;
+ case PENDING_OPEN:
+ publicState = CameraState.PENDING_OPEN;
+ break;
+ case OPENING:
+ case REOPENING:
+ publicState = CameraState.OPENING;
+ break;
+ case OPENED:
+ publicState = CameraState.OPEN;
+ break;
+ case CLOSING:
+ publicState = CameraState.CLOSING;
+ break;
+ case RELEASING:
+ publicState = CameraState.RELEASING;
+ break;
+ case RELEASED:
+ publicState = CameraState.RELEASED;
+ break;
+ default:
+ throw new IllegalStateException("Unknown state: " + state);
+
+ }
+ CameraLogger.i(TAG, "camera state change publish_state(%s -> %s) , inner_state(%s -> %s) ",
+ mCameraPublishState, publicState, mState, state);
+ mState = state;
+ mCameraPublishState = publicState;
+ mCameraPublishStateLD.postValue(mCameraPublishState);
+ mStateObserver.notifyStateChange(mCameraPublishState);
+ }
+
+ private final CameraStateObservable mStateObserver = new CameraStateObservable();
+
+ /**
+ * 立即更新的相机状态，更新时机为相机线程中，立即更新
+ */
+ public CameraStateObservable getCameraStateImmediatelyObservable() {
+ return mStateObserver;
+ }
+
+ /**
+ * UI线程更新的相机状态更新
+ */
+ public MutableLiveData getCameraStateObservable() {
+ return mCameraPublishStateLD;
+ }
+
+ public CameraState getCameraState() {
+ return mCameraPublishState;
+ }
+
+ @ExecutedBy("mExecutor")
+ private void resetCaptureSessionInner() {
+ SyncCaptureSession oldCaptureSession = mCaptureSession;
+ if (oldCaptureSession != null) {
+ oldCaptureSession.release();
+ }
+ mCaptureSession = new SyncCaptureSession(Camera2CameraImpl.this, mHandler);
+ }
+
+ public void resetCaptureSession() {
+ mExecutor.execute(this::resetCaptureSessionInner);
+ }
+
+
+ public void doRepeatingCaptureAction(@NonNull RepeatCaptureRequestConfig config) {
+ if (mCaptureSession != null) {
+ mCaptureSession.doRepeatingCaptureAction(config);
+ }
+ }
+
+
+ @ExecutedBy("mExecutor")
+ private void onErrorInternal(@NonNull CameraDevice cameraDevice, int error) {
+ Preconditions.cameraThreadCheck();
+ // onError could be called before onOpened if there is an error opening the camera
+ // during initialization, so keep track of it here.
+ mCameraDevice = cameraDevice;
+ mCameraDeviceError = error;
+
+ switch (mState) {
+ case RELEASING:
+ case CLOSING:
+ CameraLogger.e(TAG, String.format("CameraDevice.onError(): %s failed with %s while "
+ + "in %s state. Will finish closing camera.",
+ mCameraId, CameraLogger.getCameraErrorMessage(error), mState.name()));
+ closeCamera();
+ break;
+ case OPENING:
+ case OPENED:
+ case REOPENING:
+ CameraLogger.e(TAG, String.format("CameraDevice.onError(): %s failed with %s while "
+ + "in %s state. Will attempt recovering from error.",
+ mCameraId, CameraLogger.getCameraErrorMessage(error), mState.name()));
+ handleErrorOnOpen(error);
+ break;
+ default:
+ throw new IllegalStateException(
+ "onError() should not be possible from state: " + mState);
+ }
+ }
+
+
+ @ExecutedBy("mExecutor")
+ private void handleErrorOnOpen(int error) {
+ Preconditions.cameraThreadCheck();
+ CameraShould.beTrue(mState == InternalState.OPENING || mState == InternalState.OPENED || mState == InternalState.REOPENING,
+ "Attempt to handle open error from non open state: " + mState);
+ switch (error) {
+ case CameraDevice.StateCallback.ERROR_CAMERA_DEVICE:
+ // A fatal error occurred. The device should be reopened.
+ // Fall through.
+ case CameraDevice.StateCallback.ERROR_MAX_CAMERAS_IN_USE:
+ case CameraDevice.StateCallback.ERROR_CAMERA_IN_USE:
+ // Attempt to reopen the camera again. If there are no cameras available,
+ // this will wait for the next available camera.
+ CameraLogger.i(TAG, String.format("Attempt to reopen camera[%s] after error[%s]",
+ mCameraId, CameraLogger.getCameraErrorMessage(error)));
+ reopenCameraAfterError();
+ break;
+ default:
+ // TODO: Properly handle other errors. For now, we will close the camera.
+ CameraLogger.e(
+ TAG,
+ "Error observed on open (or opening) camera device "
+ + mCameraId
+ + ": "
+ + CameraLogger.getCameraErrorMessage(error)
+ + " closing camera.");
+ setState(InternalState.CLOSING);
+ closeCamera();
+ break;
+ }
+
+
+ }
+
+ public void capture(@NonNull SingleCaptureConfig singleCaptureConfig,
+ @NonNull InnerImageCaptureCallback capturedCallback) {
+ try {
+ mExecutor.execute(() -> captureInner(singleCaptureConfig, capturedCallback));
+ } catch (RejectedExecutionException e) {
+ capturedCallback.onError(e);
+ }
+ }
+
+
+ private void captureInner(SingleCaptureConfig singleCaptureConfig,
+ @NonNull InnerImageCaptureCallback capturedCallback) {
+ CameraLogger.i(TAG, "begin issue capture request when %s", mState);
+ switch (mState) {
+ case OPENED:
+ try {
+ mCaptureSession.capture(singleCaptureConfig, mCameraDevice, capturedCallback);
+ } catch (Exception e) {
+ capturedCallback.onError(new IllegalStateException(e));
+ }
+ break;
+ //TODO only test capture error case
+// mStateCallback.mScheduler.schedule(() -> {
+// mTestCaptureError = true;
+// mExecutor.execute(() -> onErrorInternal(mCameraDevice, CameraDevice.StateCallback.ERROR_CAMERA_DEVICE));
+// return null;
+// }, 5000);
+ default:
+ capturedCallback.onError(new IllegalStateException("capture request when " + mState));
+ break;
+ }
+ }
+
+
+ @ExecutedBy("mExecutor")
+ private void reopenCameraAfterError() {
+ // After an error, we must close the current camera device before we can open a new
+ // one. To accomplish this, we will close the current camera and wait for the
+ // onClosed() callback to reopen the device. It is also possible that the device can
+ // be closed immediately, so in that case we will open the device manually.
+ Preconditions.checkState(mCameraDeviceError != ERROR_NONE,
+ "Can only reopen camera device after error if the camera device is actually "
+ + "in an error state.");
+ setState(InternalState.REOPENING);
+ mCameraDevice.close();
+ }
+
+
+ public void close() {
+ mExecutor.execute(this::closeInternal);
+ }
+
+ @ExecutedBy("mExecutor")
+ private void closeInternal() {
+ Preconditions.cameraThreadCheck();
+ CameraLogger.i(TAG, "closeInternal when %s", mState);
+
+ switch (mState) {
+ case OPENED:
+ setState(InternalState.CLOSING);
+ closeCamera();
+ break;
+ case PENDING_OPEN:
+ //等待有效相机，直接标志为关闭成功
+ setState(InternalState.INITIALIZED);
+ break;
+ case OPENING:
+ case REOPENING:
+ setState(InternalState.CLOSING);
+ boolean canFinish = mStateCallback.cancelScheduledReopen();
+ if (canFinish) {
+ finishClose();
+ }
+ break;
+ }
+
+ }
+
+
+ @ExecutedBy("mExecutor")
+ private void closeCamera() {
+ Preconditions.cameraThreadCheck();
+
+ /**
+ * opened状态之后的, 需要releaseCaptureSession
+ *
+ * @TestLog
+ * TEST: 假设相机先关闭,然后延迟关闭{@link CameraCaptureSession#close()} 会发生 看看会发生什么
+ * TEST_RESULT:{@link CameraCaptureSession.StateCallback#onClosed(CameraCaptureSession)}还是会触发触发,所以依赖closed完成Surface回收没有问题
+ *
+ * TEST: OPPO R9m Android 5.1 这个机器, {@link CameraCaptureSession#close()} 不会回调 {@link CameraCaptureSession.StateCallback#onClosed(CameraCaptureSession)}还
+ * 这样导致的我surface无法回收
+ * TEST_RESULT:强制在相机关闭的时候，再forceRelease一下
+ *
+ */
+ if (mCaptureSession != null) {
+ mCaptureSession.release();
+ }
+
+ mCameraDevice.close();
+
+ mCameraDevice = null;
+ }
+
+ public void release() {
+ mExecutor.execute(this::releaseInner);
+ }
+
+ private void releaseInner() {
+ CameraLogger.i(TAG, "release camera when %s", mState);
+
+ mStateCallback.cancelScheduledReopen();
+
+ if (mCaptureSession != null) {
+ mCaptureSession.forceRelease();
+ mCaptureSession = null;
+ }
+
+ mStateObserver.clear();
+
+ mSessionConfig = null;
+ mErrorListener = new ComboCameraErrorListener(null);
+ }
+
+
+ public @NonNull
+ CameraCharacteristics getCameraCharacteristics() {
+ return mCameraCharacteristics;
+ }
+
+ public void setCameraCharacteristics(CameraCharacteristics cameraCharacteristics) {
+ mCameraCharacteristics = cameraCharacteristics;
+ mCamera2Info.setCameraCharacteristics(mCameraCharacteristics);
+ }
+
+ public Camera2Info getCamera2Info() {
+ return mCamera2Info;
+ }
+
+ public String getCameraId() {
+ return mCameraId;
+ }
+
+ public Camera2Control getControl() {
+ return mControl;
+ }
+
+
+ class CameraReopenMonitor {
+ // Time limit since the first camera reopen attempt after which reopening the camera
+ // should no longer be attempted.
+ static final int REOPEN_LIMIT_MS = 5_000;
+ static final int INVALID_TIME = -1;
+ private long mFirstReopenTime = INVALID_TIME;
+
+ boolean canScheduleCameraReopen() {
+ final long now = SystemClock.uptimeMillis();
+
+ // If it's the first attempt to reopen the camera
+ if (mFirstReopenTime == INVALID_TIME) {
+ mFirstReopenTime = now;
+ return true;
+ }
+
+ final boolean hasReachedLimit = now - mFirstReopenTime >= REOPEN_LIMIT_MS;
+
+ // If the limit has been reached, prevent further attempts to reopen the camera,
+ // and reset [firstReopenTime].
+ if (hasReachedLimit) {
+ reset();
+ return false;
+ }
+
+ return true;
+ }
+
+ void reset() {
+ mFirstReopenTime = INVALID_TIME;
+ }
+ }
+
+ /**
+ * A {@link Runnable} which will attempt to reopen the camera after a scheduled delay.
+ */
+ class ScheduledReopen implements Callable {
+
+ private final Executor mExecutor;
+ private boolean mCancelled = false;
+
+ ScheduledReopen(@NonNull Executor executor) {
+ mExecutor = executor;
+ }
+
+ void cancel() {
+ mCancelled = true;
+ }
+
+
+ @Override
+ public Boolean call() throws Exception {
+ mExecutor.execute(() -> {
+ // Scheduled reopen may have been cancelled after execute(). Check to ensure
+ // this is still the scheduled reopen.
+ if (!mCancelled) {
+ Preconditions.checkState(mState == InternalState.REOPENING);
+ openCameraDevices(/*fromScheduledCameraReopen=*/true);
+ }
+ });
+ return true;
+ }
+ }
+
+
+ public void updateDisplayRotationDetector(DisplayOrientationDetector displayOrientationDetector) {
+ mCamera2Info.setDisplayOrientationDetector(displayOrientationDetector);
+ }
+
+
+}
\ No newline at end of file
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/Camera2Control.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/Camera2Control.java
new file mode 100644
index 000000000..0dc1d5d02
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/Camera2Control.java
@@ -0,0 +1,99 @@
+package com.quark.quamera.camera.camera;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-18
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraMetadata;
+import android.hardware.camera2.CaptureRequest;
+import android.os.Build;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import com.quark.quamera.camera.session.CameraCaptureCallback;
+import com.quark.quamera.camera.session.RepeatCaptureRequestConfig;
+import com.quark.quamera.camera.session.config.CameraConfigUtils;
+import com.quark.quamera.util.ArrayUtil;
+
+import java.util.concurrent.Executor;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class Camera2Control {
+ private final Camera2CameraImpl mCamera2Camera;
+
+
+ public Camera2Control(Camera2CameraImpl camera2Camera) {
+ mCamera2Camera = camera2Camera;
+ }
+
+
+ public void enableFlash(boolean enable, CameraCaptureCallback callback, Executor executor) {
+ RepeatCaptureRequestConfig requestConfig;
+ if (enable) {
+ requestConfig = new RepeatCaptureRequestConfig() {
+ @Override
+ public void fillConfig(@NonNull Camera2Info cameraInfo, @NonNull CaptureRequest.Builder builder) {
+ CameraCharacteristics cameraCharacteristics = cameraInfo.getCameraCharacteristics();
+ //AE: 自动曝光不要设置有flash的模式
+ //When this control is used, the CaptureRequest#CONTROL_AE_MODE must be set to ON or OFF.
+ // Otherwise, the camera device auto-exposure related flash control (ON_AUTO_FLASH, ON_ALWAYS_FLASH, or ON_AUTO_FLASH_REDEYE) will override this control.
+
+ CameraConfigUtils.checkAndSetConfigIntValue(cameraCharacteristics, builder,
+ CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES, CaptureRequest.CONTROL_AE_MODE, CameraMetadata.CONTROL_AE_MODE_ON);
+
+
+ Boolean enableFlash = cameraCharacteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE);
+ if (enableFlash != null && enableFlash) {
+ builder.set(CaptureRequest.FLASH_MODE, CaptureRequest.FLASH_MODE_TORCH);
+ }
+
+ builder.setTag("flash_torch");
+ }
+
+ @Override
+ public CameraCaptureCallback getCallback() {
+ return callback;
+ }
+
+ @Override
+ public Executor getCallbackExecutor() {
+ return executor;
+ }
+ };
+ } else {
+ requestConfig = new RepeatCaptureRequestConfig() {
+ @Override
+ public void fillConfig(@NonNull Camera2Info cameraInfo, @NonNull CaptureRequest.Builder builder) {
+ CameraCharacteristics cameraCharacteristics = cameraInfo.getCameraCharacteristics();
+ Boolean enableFlash = cameraCharacteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE);
+ if (enableFlash != null && enableFlash) {
+ builder.set(CaptureRequest.FLASH_MODE, CaptureRequest.FLASH_MODE_OFF);
+ }
+ builder.setTag("flash_off");
+ }
+
+ @Override
+ public CameraCaptureCallback getCallback() {
+ return callback;
+ }
+
+ @Override
+ public Executor getCallbackExecutor() {
+ return executor;
+ }
+
+ };
+ }
+
+ mCamera2Camera.doRepeatingCaptureAction(requestConfig);
+ }
+
+ public Camera2CameraImpl getCamera2Camera() {
+ return mCamera2Camera;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/Camera2Info.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/Camera2Info.java
new file mode 100644
index 000000000..c37d961fd
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/Camera2Info.java
@@ -0,0 +1,320 @@
+package com.quark.quamera.camera.camera;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-14
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.graphics.Rect;
+import android.hardware.camera2.CameraCharacteristics;
+import android.os.Build;
+import android.util.Log;
+import android.util.Range;
+import android.util.Size;
+import android.util.SizeF;
+
+import com.quark.quamera.camera.sensor.DisplayOrientationDetector;
+import com.quark.quamera.camera.sensor.ImageRotationHelper;
+import com.quark.quamera.camera.session.CameraSelector;
+import com.quark.quamera.util.CameraInit;
+import com.quark.quamera.util.CameraLogger;
+import com.quark.quamera.util.CameraShould;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class Camera2Info {
+ // 最大的水平广角 超过认为是超广角 可能会导致变形
+ private static final int MAX_ANGLE = 90;
+
+ private CameraCharacteristics mCameraCharacteristics;
+
+ private final String mCameraId;
+
+ private boolean mIsFrontCamera;
+
+ private ImageRotationHelper mImageRotationHelper;
+
+ private Rect mSensorRect;
+
+ public Camera2Info(@NonNull String cameraId) {
+ mCameraId = cameraId;
+ }
+
+ public void setCameraCharacteristics(@NonNull CameraCharacteristics cameraCharacteristics) {
+ mCameraCharacteristics = cameraCharacteristics;
+ initCommonInfo();
+ calculateFOV();
+ printCameraInfo();
+ }
+
+ private void initCommonInfo() {
+ try {
+ mIsFrontCamera =
+ mCameraCharacteristics.get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_FRONT;
+ mSensorRect = mCameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
+ } catch (Exception e) {
+ mSensorRect = null;
+ }
+ }
+
+ public boolean isFrontCamera() {
+ return mIsFrontCamera;
+ }
+
+ public Rect getSensorRect() {
+ return mSensorRect;
+ }
+
+ public void setDisplayOrientationDetector(DisplayOrientationDetector detector) {
+ mImageRotationHelper = new ImageRotationHelper(this, detector);
+ }
+
+ public ImageRotationHelper getImageRotationHelper() {
+ return mImageRotationHelper;
+ }
+
+ private void printCameraInfo() {
+ if (!CameraInit.getConfig().isDebuggable()) {
+ return;
+ }
+
+ CameraLogger.i("CameraLifeManager", getCameraInfoMessage());
+ }
+
+ /**
+ * active_array_aspect = ACTIVE_ARRAY.w / ACTIVE_ARRAY.h
+ * output_a_aspect = output_a.w / output_a.h
+ * output_b_aspect = output_b.w / output_b.h
+ * output_a_physical_height = SENSOR_INFO_PHYSICAL_SIZE.y * ACTIVE_ARRAY.h / PIXEL_ARRAY.h * output_a_aspect / active_array_aspect
+ * output_b_physical_height = SENSOR_INFO_PHYSICAL_SIZE.y * ACTIVE_ARRAY.h / PIXEL_ARRAY.h * output_b_aspect / active_array_aspect
+ * FOV_a_y = 2 * atan(output_a_physical_height / (2 * LENS_FOCAL_LENGTH))
+ * FOV_b_y = 2 * atan(output_b_physical_height / (2 * LENS_FOCAL_LENGTH))
+ *
+ * @return
+ */
+
+
+ public CameraCharacteristics getCameraCharacteristics() {
+ return mCameraCharacteristics;
+ }
+
+ public int getSensorOrientation() {
+ Integer sensorOrientation =
+ mCameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
+ return sensorOrientation != null ? sensorOrientation : 0;
+ }
+
+ public CameraSelector.CameraLenFacing getCameraLenFacing() {
+ Integer lens_facing = mCameraCharacteristics.get(CameraCharacteristics.LENS_FACING);
+ if (lens_facing == null) {
+ return null;
+ }
+ if (lens_facing == CameraCharacteristics.LENS_FACING_FRONT) {
+ return CameraSelector.CameraLenFacing.LEN_FACING_FONT;
+ } else if (lens_facing == CameraCharacteristics.LENS_FACING_BACK) {
+ return CameraSelector.CameraLenFacing.LEN_FACING_BACK;
+ }
+ return null;
+ }
+
+ public static final float INVALID_FOCAL_LENGTH = Float.MAX_VALUE;
+
+ public static class FocalLengthInfo implements Comparable {
+ public float focalLength = INVALID_FOCAL_LENGTH;
+ public double horizontalAngle = 0; //0 ~ pi
+ public double verticalAngle = 0; //0 ~ pi
+ public boolean isDefaultFocal = false;
+
+ @Override
+ public int compareTo(FocalLengthInfo o) {
+ if (o == this) {
+ return 0;
+ }
+ //never happen
+ if (focalLength == o.focalLength) {
+ return 0;
+ }
+
+ return focalLength > o.focalLength ? 1 : -1;
+ }
+ }
+
+ public String getCameraId() {
+ return mCameraId;
+ }
+
+ private final List mFocalLengthInfos = new ArrayList<>();
+
+
+ /**
+ * https://stackoverflow.com/questions/39965408/what-is-the-android-camera2-api-equivalent-of-camera-parameters-gethorizontalvie
+ *
+ * FOV.x = 2 * atan(SENSOR_INFO_PHYSICAL_SIZE.x / (2 * LENS_FOCAL_LENGTH))
+ * FOV.y = 2 * atan(SENSOR_INFO_PHYSICAL_SIZE.y / (2 * LENS_FOCAL_LENGTH))
+ *
+ *
+ * ignore sensor_pixel info and capture crop region first @(- 3 -)
+ */
+ private void calculateFOV() {
+
+ mFocalLengthInfos.clear();
+
+ try {
+
+ SizeF size = mCameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_PHYSICAL_SIZE);
+
+ float[] focalLens = mCameraCharacteristics.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS);
+
+ double width = size.getWidth();
+
+ double height = size.getHeight();
+
+
+ boolean firstOne = true;
+ for (float focalLength : focalLens) {
+ FocalLengthInfo lengthInfo = new FocalLengthInfo();
+ lengthInfo.horizontalAngle = (2 * Math.atan(width / (focalLength * 2)));
+ lengthInfo.verticalAngle = (2 * Math.atan(height / (focalLength * 2)));
+ lengthInfo.focalLength = focalLength;
+ //一般情况下，第一个焦距信息为默认焦距
+ lengthInfo.isDefaultFocal = firstOne;
+ firstOne = false;
+ mFocalLengthInfos.add(lengthInfo);
+ }
+
+ Collections.sort(mFocalLengthInfos);
+
+
+ } catch (Exception e) {
+ CameraShould.fail("", e);
+ }
+
+ }
+
+
+ public List getFocalLengthInfos() {
+ return mFocalLengthInfos;
+ }
+
+ /**
+ * 返回最佳的焦距信息
+ */
+ public FocalLengthInfo getBestFocalInfo() {
+ for (FocalLengthInfo info : mFocalLengthInfos) {
+ double angle = info.horizontalAngle * 180 / Math.PI;
+ if (angle <= MAX_ANGLE) {
+ return info;
+ }
+ }
+ // 如果所有焦距对应角度都大于90 选择默认焦距
+ return getDefaultFocalInfo();
+ }
+
+ /**
+ * 一般而言，就是默认的焦距
+ */
+ public FocalLengthInfo getDefaultFocalInfo() {
+ for (FocalLengthInfo info : mFocalLengthInfos) {
+ if (info.isDefaultFocal) {
+ return info;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * 输出当前物理镜头焦距 广角等信息
+ */
+ public String getCameraInfoMessage() {
+ Integer support_level = mCameraCharacteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
+
+ StringBuilder cameraInfo = new StringBuilder(" \n{\n");
+ cameraInfo.append("cameraId:").append(mCameraId).append(",\nsupport_level:").append(support_level);
+ cameraInfo.append("\n");
+ if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
+ Range zoom_range = mCameraCharacteristics.get(CameraCharacteristics.CONTROL_ZOOM_RATIO_RANGE);
+ cameraInfo.append("zoom_range:[").append(zoom_range.getLower()).append(":").append(zoom_range.getUpper()).append("]").append(",\n");
+ }
+
+ float max_digital_zoom = mCameraCharacteristics.get(CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM);
+ cameraInfo.append("max_digital_zoom:").append(max_digital_zoom).append(",");
+ cameraInfo.append("\n");
+
+ SizeF sensorPhysicalSize = mCameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_PHYSICAL_SIZE);
+
+ cameraInfo.append(String.format(Locale.CHINA, "physical: %.2f * %.2f ", sensorPhysicalSize.getWidth(), sensorPhysicalSize.getHeight())).append(",\n");
+
+ Size sensorPixelSize = mCameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_PIXEL_ARRAY_SIZE);
+
+ cameraInfo.append(String.format(Locale.CHINA, "pixel: %d * %d ", sensorPixelSize.getWidth(), sensorPixelSize.getHeight())).append(",\n");
+
+ //active pixel info log
+ if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.P) {
+ int[] distortion_modes =
+ mCameraCharacteristics.get(CameraCharacteristics.DISTORTION_CORRECTION_AVAILABLE_MODES);
+
+ cameraInfo.append("distortion_correction_modes : [");
+ if (distortion_modes != null) {
+ for (int value : distortion_modes) {
+ cameraInfo.append(value).append(",");
+ }
+ } else {
+ cameraInfo.append("null");
+ }
+ cameraInfo.append("]");
+ cameraInfo.append("\n");
+ }
+
+ if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
+ Rect preCorrectionActiveArraySize =
+ mCameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
+ cameraInfo.append(String.format(Locale.CHINA, "pre_correction_active_array_size: %s ", preCorrectionActiveArraySize)).append(",\n");
+ }
+
+ Rect sensorActiveArrayRect = mCameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
+
+ cameraInfo.append(String.format(Locale.CHINA, "active_rect: %s ", sensorActiveArrayRect)).append(",\n");
+
+ cameraInfo.append("focal_info {");
+ for (FocalLengthInfo focalLengthInfo : mFocalLengthInfos) {
+ float active_array_aspect = ((float) sensorActiveArrayRect.width()) / sensorActiveArrayRect.height();
+ float output_a_aspect = 3648f / 2736f;
+ float output_a_physical_height = sensorPhysicalSize.getHeight() * sensorActiveArrayRect.height() / sensorPixelSize.getHeight() * output_a_aspect / active_array_aspect;
+ float fov_a_y = (float) (2 * Math.atan(output_a_physical_height / (2 * focalLengthInfo.focalLength)));
+
+ Log.e("CameraLife", "active_array_aspect: " + active_array_aspect);
+ cameraInfo.append("\n ").append(String.format(Locale.CHINA, "foca: l_length:%.2f h_angle:%.2f " +
+ "v_angle:%.2f fov_a_y:%.2f ",
+ focalLengthInfo.focalLength, focalLengthInfo.horizontalAngle / Math.PI * 180,
+ focalLengthInfo.verticalAngle / Math.PI * 180, fov_a_y / Math.PI * 180)).append(",");
+ }
+ cameraInfo.append("\n}\n");
+ cameraInfo.append("}");
+ return cameraInfo.toString();
+ }
+
+ public String getSelectCameraInfoMsg() {
+ StringBuilder cameraInfo = new StringBuilder();
+ // 当前选择的镜头焦距信息
+ FocalLengthInfo bestFocalInfo = getBestFocalInfo();
+ if (bestFocalInfo != null) {
+ cameraInfo.append("{")
+ .append("\n ").append(String.format(Locale.CHINA, "l_length:%.2f, \nh_angle:%.2f,\n" +
+ "v_angle:%.2f",
+ bestFocalInfo.focalLength, bestFocalInfo.horizontalAngle / Math.PI * 180,
+ bestFocalInfo.verticalAngle / Math.PI * 180));
+ cameraInfo.append("}");
+ }
+ return cameraInfo.toString();
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraErrorListenerHandlerWrapper.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraErrorListenerHandlerWrapper.java
new file mode 100644
index 000000000..73f8a5d0e
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraErrorListenerHandlerWrapper.java
@@ -0,0 +1,30 @@
+package com.quark.quamera.camera.camera;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-21
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.os.Handler;
+
+import androidx.annotation.NonNull;
+
+
+public class CameraErrorListenerHandlerWrapper implements ICameraErrorListener {
+
+ private Handler mHandler;
+
+ private ICameraErrorListener mListener;
+
+ public CameraErrorListenerHandlerWrapper(@NonNull Handler handler, @NonNull ICameraErrorListener listener) {
+ mHandler = handler;
+ mListener = listener;
+ }
+
+ @Override
+ public void onError(int cameraError, String message) {
+ mHandler.post(() -> mListener.onError(cameraError, message));
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraLifeManager.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraLifeManager.java
new file mode 100644
index 000000000..3f855bb25
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraLifeManager.java
@@ -0,0 +1,169 @@
+package com.quark.quamera.camera.camera;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-24
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.content.Context;
+import android.os.Build;
+import android.util.Size;
+
+import com.quark.quamera.camera.preview.IPreviewView;
+import com.quark.quamera.camera.sensor.DisplayOrientationDetector;
+import com.quark.quamera.camera.sensor.ImageRotationHelper;
+import com.quark.quamera.camera.session.CameraCaptureCallback;
+import com.quark.quamera.camera.session.CameraSelector;
+import com.quark.quamera.camera.session.ImageCapture;
+import com.quark.quamera.camera.session.SessionConfig;
+import com.quark.quamera.camera.session.SingleCaptureConfig;
+import com.quark.quamera.util.CameraLogger;
+import com.quark.quamera.util.Preconditions;
+
+import java.util.List;
+import java.util.concurrent.Executor;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.lifecycle.MutableLiveData;
+import androidx.lifecycle.Observer;
+
+//保证一次只有一个相机
+//所有相机的生命管理
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class CameraLifeManager {
+ private Camera2CameraImpl mCurrentCamera;
+ private ImageCapture mImageCapture;
+
+ private final CameraRepository mCameraRepository;
+
+ private final DisplayOrientationDetector mOrientationHelper;
+
+
+ private final Observer mCameraStateObserver = new Observer() {
+ @Override
+ public void onChanged(CameraState cameraState) {
+ if (cameraState == CameraState.OPEN) {
+ mOrientationHelper.start();
+ } else if (cameraState == CameraState.CLOSED) {
+ mOrientationHelper.stop();
+ }
+ }
+ };
+
+
+ public CameraLifeManager(Context context, CameraRepository cameraRepository) {
+ mCameraRepository = cameraRepository;
+ mOrientationHelper = new DisplayOrientationDetector(context, Camera2CameraImpl.TAG);
+ }
+
+
+ public boolean openCamera(@NonNull CameraSelector cameraSelector, @NonNull SessionConfig config) {
+ Preconditions.checkState(cameraSelector != null);
+ Preconditions.checkState(config != null);
+
+ List mathCameraList = mCameraRepository.filterCamera(cameraSelector);
+
+ if (mathCameraList == null) {
+ return false;
+ }
+
+ if (!mathCameraList.iterator().hasNext()) {
+ CameraLogger.uploadError("NotMatchCamera", "not found " + cameraSelector.toLogString());
+ return false;
+ }
+
+ Camera2CameraImpl camera2Camera = mathCameraList.iterator().next();
+
+ if (camera2Camera == null) {
+ return false;
+ }
+
+ if (mCurrentCamera != null) {
+ mCurrentCamera.close();
+ mCurrentCamera.getCameraStateObservable().removeObserver(mCameraStateObserver);
+ mCurrentCamera = null;
+ }
+
+ mCurrentCamera = camera2Camera;
+ mCurrentCamera.updateDisplayRotationDetector(mOrientationHelper);
+
+ try {
+ CameraSurfaceHelper.configPreviewSize(config.getPreviewConfig(), mCurrentCamera);
+
+ IPreviewView previewView = config.getPreviewConfig().getPreviewView();
+ previewView.updateCameraSurfaceSize(
+ new Size(config.getPreviewConfig().getActualWidth(),
+ config.getPreviewConfig().getActualHeight()));
+
+ if (config.getPreviewConfig().getImageReaders() != null) {
+ CameraSurfaceHelper.configImageReader(
+ config.getPreviewConfig().getImageReaders(), mCurrentCamera,
+ new ImageRotationHelper(mCurrentCamera.getCamera2Info(), mOrientationHelper)
+ );
+ }
+
+ if (config.getImageCapture() != null) {
+ CameraSurfaceHelper.configImageCaptureSize(config.getImageCapture(),
+ mCurrentCamera,
+ new ImageRotationHelper(mCurrentCamera.getCamera2Info(), mOrientationHelper));
+
+
+ config.getImageCapture().bindCamera(mCurrentCamera);
+ config.getImageCapture().bindPreviewView(config.getPreviewConfig().getPreviewView());
+ mImageCapture = config.getImageCapture();
+ }
+
+
+ } catch (Exception e) {
+ Preconditions.onException(e);
+ return false;
+ }
+
+ mCurrentCamera.updateSessionConfig(config);
+ mCurrentCamera.resetCaptureSession();
+ mCurrentCamera.open();
+
+ mCurrentCamera
+ .getCameraStateObservable()
+ .observeForever(mCameraStateObserver);
+ return true;
+ }
+
+
+ public void enableFlash(boolean flash, CameraCaptureCallback callback, Executor executor) {
+ if (mCurrentCamera != null) {
+ mCurrentCamera.getControl().enableFlash(flash, callback, executor);
+ }
+ }
+
+ public void takePicture(@NonNull SingleCaptureConfig singleCaptureConfig,
+ @NonNull ImageCapture.OnImageCapturedCallback capturedCallback) {
+ if (mImageCapture != null) {
+ mImageCapture.takePicture(singleCaptureConfig, capturedCallback);
+ } else {
+ capturedCallback.onError(new IllegalStateException("not config image capture"));
+ }
+ }
+
+ public MutableLiveData getCurrentCameraState() {
+ return mCurrentCamera != null ? mCurrentCamera.getCameraStateObservable() : null;
+ }
+
+ public Camera2Info getCamera2Info(){
+ return mCurrentCamera != null ? mCurrentCamera.getCamera2Info() : null;
+ }
+
+ public void closeCamera() {
+ if (mCurrentCamera != null) {
+ mCurrentCamera.close();
+ mOrientationHelper.forceQuit();
+ mCurrentCamera.getCameraStateObservable().removeObserver(mCameraStateObserver);
+ mCurrentCamera = null;
+ mImageCapture = null;
+ }
+ }
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraManagerCompatApi28Impl.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraManagerCompatApi28Impl.java
new file mode 100644
index 000000000..dbcf30264
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraManagerCompatApi28Impl.java
@@ -0,0 +1,101 @@
+package com.quark.quamera.camera.camera;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/3/29
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraDevice;
+import android.hardware.camera2.CameraManager;
+import android.os.Build;
+import android.os.Handler;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import static android.hardware.camera2.CameraAccessException.CAMERA_ERROR;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+
+public class CameraManagerCompatApi28Impl implements CameraManagerCompatImpl {
+ @Override
+ public void openCamera(@NonNull CameraManager cameraManager, @NonNull String cameraId, @NonNull Handler handler, @NonNull CameraDevice.StateCallback callback) throws CameraAccessException {
+ try {
+ // Pass through directly to the executor API that exists on this API level.
+ cameraManager.openCamera(cameraId, callback, handler);
+ } catch (CameraAccessException e) {
+ throw e;
+ } catch (IllegalArgumentException | SecurityException e) {
+ // Re-throw those RuntimeException will be thrown by CameraManager#openCamera.
+ throw e;
+ } catch (RuntimeException e) {
+ if (isDndFailCase(e)) {
+ throwDndException(e);
+ }
+ throw e;
+ }
+ }
+
+ @NonNull
+ @Override
+ public CameraCharacteristics getCameraCharacteristics(@NonNull CameraManager cameraManager, @NonNull String cameraId) throws CameraAccessException {
+ try {
+ return cameraManager.getCameraCharacteristics(cameraId);
+ } catch (RuntimeException e) {
+ if (isDndFailCase(e)) {
+ // No need to get from cache here because we always get the instance from cache in
+ // CameraManagerCompat. So when DnDFail happens, it happens only when it gets
+ // the CameraCharacteristics for the first time.
+ throwDndException(e);
+ }
+ }
+
+ return null;
+ }
+
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ private void throwDndException(@NonNull Throwable cause) throws CameraAccessException {
+ throw new CameraAccessException(CAMERA_ERROR, "CAMERA_UNAVAILABLE_DO_NOT_DISTURB", cause);
+ }
+
+
+ /*
+ * Check if the exception is due to Do Not Disturb being on, which is only on specific builds
+ * of P. See b/149413835 and b/132362603.
+ */
+ private boolean isDndFailCase(@NonNull Throwable throwable) {
+ return Build.VERSION.SDK_INT == 28 && isDndRuntimeException(throwable);
+ }
+
+
+ /*
+ * The full stack
+ *
+ * java.lang.RuntimeException: Camera is being used after Camera.release() was called
+ * at android.hardware.Camera._enableShutterSound(Native Method)
+ * at android.hardware.Camera.updateAppOpsPlayAudio(Camera.java:1770)
+ * at android.hardware.Camera.initAppOps(Camera.java:582)
+ * at android.hardware.Camera.(Camera.java:575)
+ * at android.hardware.Camera.getEmptyParameters(Camera.java:2130)
+ * at android.hardware.camera2.legacy.LegacyMetadataMapper.createCharacteristics
+ * (LegacyMetadataMapper.java:151)
+ * at android.hardware.camera2.CameraManager.getCameraCharacteristics(CameraManager.java:274)
+ *
+ * This method check the first stack is "_enableShutterSound"
+ */
+ private static boolean isDndRuntimeException(@NonNull Throwable throwable) {
+ if (throwable.getClass().equals(RuntimeException.class)) {
+ StackTraceElement[] stackTraceElement;
+ if ((stackTraceElement = throwable.getStackTrace()) == null
+ || stackTraceElement.length < 0) {
+ return false;
+ }
+ return "_enableShutterSound".equals(stackTraceElement[0].getMethodName());
+ }
+ return false;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraManagerCompatBaseImpl.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraManagerCompatBaseImpl.java
new file mode 100644
index 000000000..fdbcb3add
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraManagerCompatBaseImpl.java
@@ -0,0 +1,42 @@
+package com.quark.quamera.camera.camera;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/3/29
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraDevice;
+import android.hardware.camera2.CameraManager;
+import android.os.Build;
+import android.os.Handler;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.core.util.Preconditions;
+
+import java.util.concurrent.Executor;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+class CameraManagerCompatBaseImpl implements CameraManagerCompatImpl {
+
+
+ @SuppressLint("MissingPermission")
+ @Override
+ public void openCamera(@NonNull CameraManager cameraManager, @NonNull String cameraId, @NonNull Handler handler, @NonNull CameraDevice.StateCallback callback) throws CameraAccessException {
+ cameraManager.openCamera(cameraId, callback, handler);
+ }
+
+ @NonNull
+ @Override
+ public CameraCharacteristics getCameraCharacteristics(@NonNull CameraManager cameraManager, @NonNull String cameraId) throws CameraAccessException {
+ return cameraManager.getCameraCharacteristics(cameraId);
+ }
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraManagerCompatImpl.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraManagerCompatImpl.java
new file mode 100644
index 000000000..87bf9fce8
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraManagerCompatImpl.java
@@ -0,0 +1,43 @@
+package com.quark.quamera.camera.camera;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/3/29
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraDevice;
+import android.hardware.camera2.CameraManager;
+import android.os.Build;
+import android.os.Handler;
+
+import androidx.annotation.NonNull;
+
+import java.util.concurrent.Executor;
+
+interface CameraManagerCompatImpl {
+
+ /**
+ * Returns a {@link CameraManagerCompatImpl} instance depending on the API level
+ */
+ @NonNull
+ static CameraManagerCompatImpl from() {
+ if (Build.VERSION.SDK_INT == 28) {
+ // Can use Executor directly on API 28+
+ return new CameraManagerCompatApi28Impl();
+ }
+ // Pass compat handler to implementation.
+ return new CameraManagerCompatBaseImpl();
+ }
+
+ public void openCamera(@NonNull CameraManager cameraManager,
+ @NonNull String cameraId,
+ @NonNull Handler executor,
+ @NonNull CameraDevice.StateCallback callback) throws CameraAccessException;
+
+ @NonNull
+ public CameraCharacteristics getCameraCharacteristics(@NonNull CameraManager cameraManager, @NonNull String cameraId) throws CameraAccessException;
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraRepository.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraRepository.java
new file mode 100644
index 000000000..62043831e
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraRepository.java
@@ -0,0 +1,217 @@
+package com.quark.quamera.camera.camera;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-23
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.graphics.SurfaceTexture;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraManager;
+import android.hardware.camera2.params.StreamConfigurationMap;
+import android.os.Build;
+import android.os.Handler;
+import android.text.TextUtils;
+import android.util.Log;
+import android.util.Size;
+
+import com.quark.quamera.camera.anotaion.ExecutedBy;
+import com.quark.quamera.camera.session.CameraSelector;
+import com.quark.quamera.util.CameraLogger;
+import com.quark.quamera.util.CameraShould;
+import com.quark.quamera.util.Preconditions;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.Executor;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+/**
+ * 管理所有CameraID对应的Camera实例的仓库
+ */
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class CameraRepository {
+
+ HashMap mCameras = new HashMap<>();
+
+
+ public CameraRepository() {
+ }
+
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ @ExecutedBy("CameraExecutor")
+ public synchronized void init(@NonNull CameraManager cameraManager, Executor executor, Handler handler) {
+ Preconditions.cameraThreadCheck();
+ try {
+ mCameras.clear();
+ String[] cameraList = cameraManager.getCameraIdList();
+ for (String cameraId : cameraList) {
+ CameraCharacteristics characteristics =
+ CameraManagerCompatImpl.from().getCameraCharacteristics(cameraManager, cameraId);
+ Camera2CameraImpl camera2Camera = new Camera2CameraImpl(cameraManager, cameraId, executor, handler);
+ camera2Camera.setCameraCharacteristics(characteristics);
+ mCameras.put(cameraId, camera2Camera);
+ }
+ } catch (CameraAccessException e) {
+ CameraShould.fail("", e);
+ CameraLogger.e("CameraRepository", "init camera error \n %s", Log.getStackTraceString(e));
+ }
+ }
+
+ public synchronized List filterCamera(@NonNull CameraSelector selector) {
+
+ boolean isFrontCamera = selector.getFacing() == CameraSelector.CameraLenFacing.LEN_FACING_FONT;
+ String defaultCameraId = null;
+ List matchCameraList = new ArrayList<>();
+ for (Map.Entry entry : mCameras.entrySet()) {
+ try {
+ Camera2CameraImpl camera2Camera = entry.getValue();
+ CameraCharacteristics characteristics = camera2Camera.getCameraCharacteristics();
+
+ Integer lens_facing = characteristics.get(CameraCharacteristics.LENS_FACING);
+ if (lens_facing == null) {
+ continue;
+ }
+
+ StreamConfigurationMap streamConfigurationMap =
+ characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
+
+ Size[] sizes = streamConfigurationMap.getOutputSizes(SurfaceTexture.class);
+
+ //必须要支持预览，像TOF摄像头, 仅仅支持输出DEPTH_16的数据
+ if (sizes == null || sizes.length == 0) {
+ continue;
+ }
+
+ if (isFrontCamera) {
+ if (lens_facing == CameraCharacteristics.LENS_FACING_FRONT) {
+ matchCameraList.add(entry.getValue());
+ }
+ } else {
+ if (lens_facing == CameraCharacteristics.LENS_FACING_BACK) {
+ matchCameraList.add(entry.getValue());
+ }
+ }
+ //相机ID最小，或者是第一个相机为默认镜头，前置一般为0，后置一般为1
+ if (defaultCameraId == null) {
+ defaultCameraId = entry.getValue().getCameraId();
+ }
+ } catch (Exception e) {
+ CameraShould.fail("", e);
+ }
+ }
+
+ //使用广角优先摄像头
+ if (selector.isUseWideCamera()) {
+ //Collections.sort(matchCameraList, new DefaultFocalHorizontalFOVComparator(defaultCameraId));
+ }
+
+ //if (CameraInit.getConfig().isDebuggable()) {
+ StringBuilder sb = new StringBuilder("\n");
+ for (Camera2CameraImpl camera2Camera : matchCameraList) {
+ Camera2Info.FocalLengthInfo minFL = camera2Camera.getCamera2Info().getBestFocalInfo();
+ sb.append(String.format(Locale.CHINA, "camera (%s) min_fl: %.2f ; max_h_angle : %.2f ",
+ camera2Camera.getCameraId(),
+ (minFL != null ? minFL.focalLength : -1),
+ (minFL != null ? minFL.horizontalAngle * 180 / Math.PI : -1)))
+ .append("\n");
+ }
+ CameraLogger.i("CameraLifeManager", "print match camera list\n %s", sb);
+
+ //}
+
+
+ return matchCameraList;
+ }
+
+
+ private static class HorizontalFOVComparator implements Comparator {
+
+ @Override
+ public int compare(Camera2CameraImpl o1, Camera2CameraImpl o2) {
+ if (o1 == o2) {
+ return 0;
+ }
+
+ //将空值放后面去
+ if (o1.getCamera2Info().getBestFocalInfo() == null) {
+ return 1;
+ }
+ if (o2.getCamera2Info().getBestFocalInfo() == null) {
+ return -1;
+ }
+
+ if (o1.getCamera2Info().getBestFocalInfo().horizontalAngle
+ == o2.getCamera2Info().getBestFocalInfo().horizontalAngle) {
+
+ //相同水平FOV的情况下，比较camera_id，经验而言,camera_id比较小是主镜头
+ return o1.getCameraId().compareTo(o2.getCameraId()) > 0 ? 1 : -1;
+ }
+
+ //水平FOV越大，约靠前
+ return o1.getCamera2Info().getBestFocalInfo().horizontalAngle >
+ o2.getCamera2Info().getBestFocalInfo().horizontalAngle ? -1 : 1;
+ }
+
+ }
+
+ private static class DefaultFocalHorizontalFOVComparator implements Comparator {
+
+ private final String mDefaultCameraId;
+
+ public DefaultFocalHorizontalFOVComparator(String defaultCameraId) {
+ mDefaultCameraId = defaultCameraId;
+ }
+
+ @Override
+ public int compare(Camera2CameraImpl o1, Camera2CameraImpl o2) {
+ if (o1 == o2) {
+ return 0;
+ }
+
+ //将空值放后面去
+ if (o1.getCamera2Info().getDefaultFocalInfo() == null) {
+ return 1;
+ }
+ if (o2.getCamera2Info().getDefaultFocalInfo() == null) {
+ return -1;
+ }
+
+ if (o1.getCamera2Info().getDefaultFocalInfo().horizontalAngle
+ == o2.getCamera2Info().getDefaultFocalInfo().horizontalAngle) {
+
+ //相同FOV的情况下，将默认镜头往后排，因为我们优先希望使用广角摄像头，使用其光圈等参数设置，而不单单是FOV
+ if (TextUtils.equals(o1.getCameraId(), mDefaultCameraId)) {
+ return 1;
+ }
+
+ if (TextUtils.equals(o2.getCameraId(), mDefaultCameraId)) {
+ return -1;
+ }
+
+ //相同水平FOV的情况下，比较camera_id，经验而言,camera_id比较小是主镜头
+ return o1.getCameraId().compareTo(o2.getCameraId()) > 0 ? 1 : -1;
+ }
+
+ //水平FOV越大，约靠前
+ return o1.getCamera2Info().getDefaultFocalInfo().horizontalAngle >
+ o2.getCamera2Info().getDefaultFocalInfo().horizontalAngle ? -1 : 1;
+ }
+
+ }
+
+ public static void cameraListAutoTest() {
+
+ }
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraState.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraState.java
new file mode 100644
index 000000000..64c200214
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraState.java
@@ -0,0 +1,68 @@
+package com.quark.quamera.camera.camera;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-18
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+public enum CameraState {
+ /**
+ * Camera is waiting for resources to become available before opening.
+ *
+ * The camera will automatically transition to an {@link #OPENING} state once resources
+ * have become available. Resources are typically made available by other cameras closing.
+ */
+ PENDING_OPEN(/*holdsCameraSlot=*/false),
+ /**
+ * Camera is in the process of opening.
+ *
+ *
This is a transient state.
+ */
+ OPENING(/*holdsCameraSlot=*/true),
+ /**
+ * Camera is open and producing (or ready to produce) image data.
+ */
+ OPEN(/*holdsCameraSlot=*/true),
+ /**
+ * Camera is in the process of closing.
+ *
+ *
This is a transient state.
+ */
+ CLOSING(/*holdsCameraSlot=*/true),
+ /**
+ * Camera has been closed and should not be producing data.
+ */
+ CLOSED(/*holdsCameraSlot=*/false),
+ /**
+ * Camera is in the process of being released and cannot be reopened.
+ *
+ *
This is a transient state. Note that this state holds a camera slot even though the
+ * implementation may not actually hold camera resources.
+ */
+ // TODO: Check if this needs to be split up into multiple RELEASING states to
+ // differentiate between when the camera slot is being held or not.
+ RELEASING(/*holdsCameraSlot=*/true),
+ /**
+ * Camera has been closed and has released all held resources.
+ */
+ RELEASED(/*holdsCameraSlot=*/false);
+
+ private final boolean mHoldsCameraSlot;
+
+ CameraState(boolean holdsCameraSlot) {
+ mHoldsCameraSlot = holdsCameraSlot;
+ }
+
+ /**
+ * Returns whether a camera in this state could be holding on to a camera slot.
+ *
+ *
Holding on to a camera slot may preclude other cameras from being open. This is
+ * generally the case when the camera implementation is in the process of opening a
+ * camera, has already opened a camera, or is in the process of closing the camera.
+ */
+ boolean holdsCameraSlot() {
+ return mHoldsCameraSlot;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraStateObservable.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraStateObservable.java
new file mode 100644
index 000000000..6a35bbf6b
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraStateObservable.java
@@ -0,0 +1,64 @@
+package com.quark.quamera.camera.camera;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/6/6
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class CameraStateObservable {
+
+ private final List> mListeners = new ArrayList<>();
+
+ public void addListener(ICameraStateListener listener) {
+ synchronized (mListeners) {
+ Iterator> it = mListeners.iterator();
+ while (it.hasNext()) {
+ ICameraStateListener temp = it.next().get();
+ if (temp == null) {
+ it.remove();
+ continue;
+ }
+ if (temp == listener) {
+ return;
+ }
+ }
+ mListeners.add(new SoftReference<>(listener));
+ }
+ }
+
+ public void clear() {
+ synchronized (mListeners) {
+ mListeners.clear();
+ }
+ }
+
+ public void removeListener(ICameraStateListener listener) {
+ synchronized (mListeners) {
+
+ for (SoftReference rf : mListeners) {
+ if (rf.get() == listener) {
+ mListeners.remove(rf);
+ return;
+ }
+ }
+ }
+ }
+
+ public void notifyStateChange(CameraState to) {
+ synchronized (mListeners) {
+ for (SoftReference rf : mListeners) {
+ ICameraStateListener listener = rf.get();
+ if (listener != null) {
+ listener.onCameraStateChanged(to);
+ }
+ }
+ }
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraSurfaceHelper.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraSurfaceHelper.java
new file mode 100644
index 000000000..9165c6450
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/CameraSurfaceHelper.java
@@ -0,0 +1,610 @@
+package com.quark.quamera.camera.camera;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-23
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.graphics.Rect;
+import android.graphics.SurfaceTexture;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.params.StreamConfigurationMap;
+import android.os.Build;
+import android.util.Log;
+import android.util.Rational;
+import android.util.Size;
+import android.view.SurfaceHolder;
+
+import com.quark.quamera.camera.imagereader.DeferrableImageReader;
+import com.quark.quamera.camera.sensor.ImageRotationHelper;
+import com.quark.quamera.camera.session.ImageCapture;
+import com.quark.quamera.camera.session.PreviewConfig;
+import com.quark.quamera.util.CameraInit;
+import com.quark.quamera.util.CameraLogger;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class CameraSurfaceHelper {
+
+
+ //相机传感器默认给的图像是横的,所以最大值也是横着来设置
+ public static final Size MAX_SIZE = new Size(1920, 1080);
+
+
+ public static void configPreviewSize(PreviewConfig config, Camera2CameraImpl camera2Camera) throws Exception {
+
+ CameraCharacteristics characteristics = camera2Camera.getCameraCharacteristics();
+ StreamConfigurationMap streamConfigurationMap = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
+
+ int[] supportFormats = streamConfigurationMap.getOutputFormats();
+
+ for (int value : supportFormats) {
+ Log.e("wujm-camera", "support out format : " + Integer.toHexString(value));
+ }
+
+
+ Size actualPreviewSize = CameraSurfaceHelper.getSurfaceTextureSuggestionSize(
+ new Size(config.getExpectWidth(), config.getExpectHeight()),
+ camera2Camera,
+ config.getSuggestionCalculation() != null ?
+ config.getSuggestionCalculation() : LimitedClosestSizeCalculation.getInstance());
+
+
+ if (actualPreviewSize == null) {
+ throw new IllegalArgumentException(String.format("not match preview size for (%d,%d)", config.getExpectWidth(), config.getExpectHeight()));
+ }
+
+ config.setActualHeight(actualPreviewSize.getHeight());
+ config.setActualWidth(actualPreviewSize.getWidth());
+
+
+ CameraLogger.i("CameraLifeManager",
+ "find preview suggestion size (%d,%d) from expect (%d,%d) ",
+ config.getActualWidth(), config.getActualHeight(), config.getExpectWidth(), config.getExpectHeight());
+ }
+
+ public static void configImageCaptureSize(ImageCapture config, Camera2CameraImpl camera2Camera, ImageRotationHelper rotationHelper) {
+ DeferrableImageReader imageReader = config.getDeferrableImageReader();
+ configImageReader(Collections.singletonList(imageReader), camera2Camera, rotationHelper, config.getDeferrableImageReader().getSizeCalculation());
+ config.updateCaptureSurfaceSize(new Size(imageReader.getActualWidth(), imageReader.getActualHeight()));
+ }
+
+ public static void configImageReader(List imageReaders,
+ Camera2CameraImpl camera2Camera,
+ ImageRotationHelper rotationHelper) {
+ configImageReader(imageReaders, camera2Camera, rotationHelper, LimitedClosestSizeCalculation.getInstance());
+ }
+
+ public static void configImageReader(List imageReaders,
+ Camera2CameraImpl camera2Camera,
+ ImageRotationHelper rotationHelper,
+ ISuggestionCalculation calculation) {
+ if (imageReaders == null) {
+ return;
+ }
+
+ CameraCharacteristics characteristics = camera2Camera.getCameraCharacteristics();
+ StreamConfigurationMap streamConfigurationMap = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
+ if (streamConfigurationMap == null) {
+ return;
+ }
+
+ int[] supportFormats = streamConfigurationMap.getOutputFormats();
+
+ Arrays.sort(supportFormats);
+
+ StringBuilder sb = new StringBuilder("Camera SupportFormat ( ");
+ for (int format : supportFormats) {
+ sb.append("0x").append(Integer.toHexString(format)).append(" ");
+ }
+ sb.append(")");
+ CameraLogger.i("CameraLifeManager", sb.toString());
+
+
+ for (DeferrableImageReader imageReader : imageReaders) {
+
+ int index = Arrays.binarySearch(supportFormats, imageReader.getFormat());
+
+ if (index == -1) {
+ CameraLogger.e("CameraLifeManager", "not support image reader format 0x%s", Integer.toHexString(imageReader.getFormat()));
+ continue;
+ }
+
+ Size bestSize = getSurfaceSuggestionSize(imageReader, camera2Camera, calculation);
+ if (bestSize == null) {
+ continue;
+ }
+
+ imageReader.createAndroidImageReader(
+ bestSize.getWidth(), bestSize.getHeight(),
+ rotationHelper);
+
+
+ CameraLogger.i("CameraLifeManager",
+ "find image reader suggestion size (%d,%d) from expect (%d,%d) in format ",
+ bestSize.getWidth(), bestSize.getHeight(), imageReader.getExpectWidth(), imageReader.getExpectHeight(), imageReader.getFormat());
+ }
+ }
+
+
+ public static Size getSurfaceTextureSuggestionSize(Size previewSize, Camera2CameraImpl camera2Camera, @NonNull ISuggestionCalculation calculation) {
+
+ CameraCharacteristics characteristics = camera2Camera.getCameraCharacteristics();
+ StreamConfigurationMap streamConfigurationMap = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
+ if (streamConfigurationMap == null) {
+ return null;
+ }
+ Size[] sizes = streamConfigurationMap.getOutputSizes(SurfaceTexture.class);
+
+ if (CameraInit.getConfig().isDebuggable()) {
+ StringBuilder sb = new StringBuilder("[");
+ for (Size size : sizes) {
+ sb.append(" (").append(size.getWidth()).append("*").append(size.getHeight()).append(") ,");
+ }
+ sb.append("]");
+ CameraLogger.i("CameraLifeManager", "surface size Support : %s", sb);
+ }
+ Rect senorRect = characteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
+ Size senorSize = characteristics.get(CameraCharacteristics.SENSOR_INFO_PIXEL_ARRAY_SIZE);
+ return calculation.getSuggestionSize(senorSize, senorRect, sizes, previewSize.getWidth(),
+ previewSize.getHeight());
+ }
+
+ public static Size getSurfaceViewSuggestionSize(Size previewSize, Camera2CameraImpl camera2Camera, @NonNull ISuggestionCalculation calculation) {
+
+ CameraCharacteristics characteristics = camera2Camera.getCameraCharacteristics();
+ StreamConfigurationMap streamConfigurationMap = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
+ if (streamConfigurationMap == null) {
+ return null;
+ }
+ Rect senorRect = characteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
+ Size senorSize = characteristics.get(CameraCharacteristics.SENSOR_INFO_PIXEL_ARRAY_SIZE);
+ Size[] sizes = streamConfigurationMap.getOutputSizes(SurfaceHolder.class);
+
+ return calculation.getSuggestionSize(senorSize, senorRect, sizes, previewSize.getWidth(),
+ previewSize.getHeight());
+ }
+
+ public static Size getSurfaceSuggestionSize(@NonNull DeferrableImageReader imageReader, Camera2CameraImpl camera2Camera, @NonNull ISuggestionCalculation calculation) {
+
+ CameraCharacteristics characteristics = camera2Camera.getCameraCharacteristics();
+ StreamConfigurationMap streamConfigurationMap = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
+ if (streamConfigurationMap == null) {
+ return null;
+ }
+ Rect senorRect = characteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
+ Size senorSize = characteristics.get(CameraCharacteristics.SENSOR_INFO_PIXEL_ARRAY_SIZE);
+
+ Size[] sizes = streamConfigurationMap.getOutputSizes(imageReader.getFormat());
+ if (CameraInit.getConfig().isDebuggable()) {
+ StringBuilder sb = new StringBuilder("[");
+ for (Size size : sizes) {
+ sb.append(" (").append(size.getWidth()).append("*").append(size.getHeight()).append(") ,");
+ }
+ sb.append("]");
+ CameraLogger.i("CameraLifeManager", "image reader size Support : %s", sb);
+ }
+
+ return calculation.getSuggestionSize(senorSize, senorRect, sizes, imageReader.getExpectWidth(),
+ imageReader.getExpectHeight());
+ }
+
+ public interface ISuggestionCalculation {
+ public Size getSuggestionSize(Size sensorSize, Rect sensorRect, Size[] sizes, int expectWidth,
+ int expectHeight);
+ }
+
+ /**
+ * 限制最大 {@link #MAX_SIZE} 的预览大小，寻找最接近
+ */
+ public static class LimitedClosestSizeCalculation implements ISuggestionCalculation {
+
+ @Override
+ public Size getSuggestionSize(Size sensorSize, Rect sensorRect, Size[] sizes, int expectWidth, int expectHeight) {
+ if (sizes == null) {
+ return null;
+ }
+
+ int minDiff = Integer.MAX_VALUE;
+ Size bestSize = null;
+ for (Size size : sizes) {
+ //最大清晰度不超过1080
+ if (getArea(size) > 1.1 * getArea(MAX_SIZE)) {
+ continue;
+ }
+ int curDiff = Math.abs(size.getWidth() - expectWidth) + Math.abs(size.getHeight() - expectHeight);
+ if (curDiff < minDiff) {
+ minDiff = curDiff;
+ bestSize = size;
+ }
+ }
+
+ return bestSize;
+ }
+
+ private static LimitedClosestSizeCalculation sInstance;
+
+ public synchronized static LimitedClosestSizeCalculation getInstance() {
+ if (sInstance == null) {
+ sInstance = new LimitedClosestSizeCalculation();
+ }
+ return sInstance;
+ }
+ }
+
+ public static class AreaClosestSizeCalculation implements ISuggestionCalculation {
+
+ @Override
+ public Size getSuggestionSize(Size sensorSize, Rect sensorRect, Size[] sizes, int expectWidth, int expectHeight) {
+ if (sizes == null) {
+ return null;
+ }
+
+ int minDiff = Integer.MAX_VALUE;
+ Size bestSize = null;
+ for (Size size : sizes) {
+ int curDiff = Math.abs(size.getWidth() - expectWidth) + Math.abs(size.getHeight() - expectHeight);
+ if (curDiff < minDiff) {
+ minDiff = curDiff;
+ bestSize = size;
+ }
+ }
+ return bestSize;
+ }
+
+ private static AreaClosestSizeCalculation sInstance;
+
+ public synchronized static AreaClosestSizeCalculation getInstance() {
+ if (sInstance == null) {
+ sInstance = new AreaClosestSizeCalculation();
+ }
+ return sInstance;
+ }
+ }
+
+ public static class MaxAreaCalculation implements ISuggestionCalculation {
+
+ @Override
+ public Size getSuggestionSize(Size sensorSize, Rect sensorRect, Size[] sizes, int expectWidth,
+ int expectHeight) {
+ long cur_size_area = 0;
+ Size bestSize = null;
+ for (Size size : sizes) {
+ long size_area = size.getHeight() * size.getHeight();
+ if (size_area > cur_size_area) {
+ cur_size_area = size_area;
+ bestSize = size;
+ }
+ }
+ return bestSize;
+ }
+
+ private static MaxAreaCalculation sInstance;
+
+ public synchronized static MaxAreaCalculation getInstance() {
+ if (sInstance == null) {
+ sInstance = new MaxAreaCalculation();
+ }
+ return sInstance;
+ }
+ }
+
+ public static class MaxSensorAspectCalculation implements ISuggestionCalculation {
+
+ @Override
+ public Size getSuggestionSize(Size sensorSize, Rect sensorRect, Size[] sizes, int expectWidth, int expectHeight) {
+
+
+ long cur_size_area = 0;
+ Size maxSize = null;
+ for (Size size : sizes) {
+ long size_area = ((long) size.getWidth()) * size.getHeight();
+ if (size_area > cur_size_area) {
+ cur_size_area = size_area;
+ maxSize = size;
+ }
+ }
+
+ float max_with_height_aspect = maxSize != null ? ((float) maxSize.getWidth() / maxSize.getHeight()) : -1;
+
+ /**
+ * 将预期的宽高转换成传感器aspect的宽高
+ */
+ int aspect_height = expectHeight;
+ int aspect_width = (int) (max_with_height_aspect * aspect_height);
+ return CameraSurfaceHelper.AreaClosestSizeCalculation.getInstance().getSuggestionSize(sensorSize, sensorRect, sizes, aspect_width, aspect_height);
+ }
+
+ private static MaxSensorAspectCalculation sInstance;
+
+ public synchronized static MaxSensorAspectCalculation getInstance() {
+ if (sInstance == null) {
+ sInstance = new MaxSensorAspectCalculation();
+ }
+ return sInstance;
+ }
+ }
+
+ public static int getArea(Size size) {
+ return size.getWidth() * size.getHeight();
+ }
+
+
+ public static class AreaAspectSizeCalculation implements ISuggestionCalculation {
+ private static final Rational ASPECT_RATIO_4_3 = new Rational(4, 3);
+ private static final Rational ASPECT_RATIO_16_9 = new Rational(16, 9);
+
+ public Size getMaxSize() {
+ return null;
+ }
+
+ public Size getMinSize() {
+ return new Size(800, 600);
+ }
+
+ @Override
+ public Size getSuggestionSize(Size sensorSize, Rect sensorRect, Size[] sizes, int expectWidth, int expectHeight) {
+ if (sizes == null) {
+ return null;
+ }
+
+ // 根据面积排序
+ Arrays.sort(sizes, new CompareSizesByArea(true));
+
+ Rational targetRatio = new Rational(expectWidth, expectHeight);
+ Size targetSize = new Size(expectWidth, expectHeight);
+
+ Size maxSize = getMaxSize();
+ Size minSize = getMinSize();
+ if (getArea(targetSize) < getArea(minSize)) {
+ minSize = targetSize;
+ }
+ // 限制最大的Size
+ List outputSizeCandidates = new ArrayList<>();
+ for (Size outputSize : sizes) {
+ if ((maxSize == null || getArea(outputSize) <= getArea(maxSize)) && getArea(outputSize) >= getArea(minSize)
+ && !outputSizeCandidates.contains(outputSize)) {
+ outputSizeCandidates.add(outputSize);
+ }
+ }
+
+ // 根据宽高比分组分辨率
+ Map> aspectRatioSizeListMap = groupSizesByAspectRatio(outputSizeCandidates);
+ // 每一组删除不必要的较大和较小的Size
+ for (Rational key : aspectRatioSizeListMap.keySet()) {
+ removeSupportedSizesByTargetSize(aspectRatioSizeListMap.get(key), targetSize);
+ }
+
+ // 目标宽高比差值绝对值 小->大 排序
+ List aspectRatios = new ArrayList<>(aspectRatioSizeListMap.keySet());
+ Collections.sort(aspectRatios,
+ new CompareAspectRatiosByDistanceToTargetRatio(targetRatio));
+
+ List supportedResolutions = new ArrayList<>();
+ for (Rational rational : aspectRatios) {
+ for (Size size : aspectRatioSizeListMap.get(rational)) {
+ if (!supportedResolutions.contains(size)) {
+ supportedResolutions.add(size);
+ }
+ }
+ }
+
+ if (supportedResolutions.isEmpty()) {
+ return sizes[0];
+ }
+ CameraLogger.i("CameraLifeManager", "className:" + getClass().getName() + " SuggestionSize: " + supportedResolutions);
+ return supportedResolutions.get(0);
+ }
+
+ private void removeSupportedSizesByTargetSize(List supportedSizesList,
+ Size targetSize) {
+ if (supportedSizesList == null || supportedSizesList.isEmpty()) {
+ return;
+ }
+
+ int indexBigEnough = -1;
+ int indexSmallEnough = -1;
+
+ List removeSizes = new ArrayList<>();
+
+ for (int i = 0; i < supportedSizesList.size(); i++) {
+ Size outputSize = supportedSizesList.get(i);
+ if (outputSize.getWidth() >= targetSize.getWidth()
+ && outputSize.getHeight() >= targetSize.getHeight()) {
+
+ if (indexBigEnough >= 0) {
+ removeSizes.add(supportedSizesList.get(indexBigEnough));
+ }
+
+ indexBigEnough = i;
+ } else {
+ if (indexSmallEnough >= 0) {
+ removeSizes.add(supportedSizesList.get(i));
+ }
+
+ indexSmallEnough = i;
+ }
+ }
+
+ supportedSizesList.removeAll(removeSizes);
+ }
+
+ private Map> groupSizesByAspectRatio(List sizes) {
+ Map> aspectRatioSizeListMap = new HashMap<>();
+
+ aspectRatioSizeListMap.put(ASPECT_RATIO_4_3, new ArrayList<>());
+ aspectRatioSizeListMap.put(ASPECT_RATIO_16_9, new ArrayList<>());
+
+ for (Size outputSize : sizes) {
+ Rational matchedKey = null;
+
+ for (Rational key : aspectRatioSizeListMap.keySet()) {
+ if (hasMatchingAspectRatio(outputSize, key)) {
+ matchedKey = key;
+
+ List sizeList = aspectRatioSizeListMap.get(matchedKey);
+ if (!sizeList.contains(outputSize)) {
+ sizeList.add(outputSize);
+ }
+ }
+ }
+
+ if (matchedKey == null) {
+ aspectRatioSizeListMap.put(
+ new Rational(outputSize.getWidth(), outputSize.getHeight()),
+ new ArrayList<>(Collections.singleton(outputSize)));
+ }
+ }
+
+ return aspectRatioSizeListMap;
+ }
+
+ private static final Size DEFAULT_SIZE = new Size(640, 480);
+ private static final int ALIGN16 = 16;
+
+ static boolean hasMatchingAspectRatio(Size resolution, Rational aspectRatio) {
+ boolean isMatch = false;
+ if (aspectRatio == null) {
+ isMatch = false;
+ } else if (aspectRatio.equals(
+ new Rational(resolution.getWidth(), resolution.getHeight()))) {
+ isMatch = true;
+ } else if (getArea(resolution) >= getArea(DEFAULT_SIZE)) {
+ isMatch = isPossibleMod16FromAspectRatio(resolution, aspectRatio);
+ }
+ return isMatch;
+ }
+
+ private static boolean isPossibleMod16FromAspectRatio(Size resolution, Rational aspectRatio) {
+ int width = resolution.getWidth();
+ int height = resolution.getHeight();
+
+ Rational invAspectRatio = new Rational(aspectRatio.getDenominator(),
+ aspectRatio.getNumerator());
+ if (width % 16 == 0 && height % 16 == 0) {
+ return ratioIntersectsMod16Segment(Math.max(0, height - ALIGN16), width, aspectRatio)
+ || ratioIntersectsMod16Segment(Math.max(0, width - ALIGN16), height,
+ invAspectRatio);
+ } else if (width % 16 == 0) {
+ return ratioIntersectsMod16Segment(height, width, aspectRatio);
+ } else if (height % 16 == 0) {
+ return ratioIntersectsMod16Segment(width, height, invAspectRatio);
+ }
+ return false;
+ }
+
+ private static boolean ratioIntersectsMod16Segment(int height, int mod16Width,
+ Rational aspectRatio) {
+ double aspectRatioWidth =
+ height * aspectRatio.getNumerator() / (double) aspectRatio.getDenominator();
+ return aspectRatioWidth > Math.max(0, mod16Width - ALIGN16) && aspectRatioWidth < (
+ mod16Width + ALIGN16);
+ }
+ }
+
+ public static class PreviewAreaAspectCalculation extends AreaAspectSizeCalculation {
+ private static final Size PREVIEW_MAX_SIZE = new Size(2000, 1500);
+ private static final Size PREVIEW_MIN_SIZE = new Size(800, 600);
+
+ @Override
+ public Size getMaxSize() {
+ return PREVIEW_MAX_SIZE;
+ }
+ @Override
+ public Size getMinSize() {
+ return PREVIEW_MIN_SIZE;
+ }
+
+ private static PreviewAreaAspectCalculation sInstance;
+
+ public synchronized static PreviewAreaAspectCalculation getInstance() {
+ if (sInstance == null) {
+ sInstance = new PreviewAreaAspectCalculation();
+ }
+ return sInstance;
+ }
+ }
+
+ public static class CaptureAreaAspectCalculation extends AreaAspectSizeCalculation {
+ private static final Size CAPTURE_MAX_SIZE = new Size(4400, 3300);
+ private static final Size CAPTURE_MIN_SIZE = new Size(1200, 900);
+
+ @Override
+ public Size getMaxSize() {
+ return CAPTURE_MAX_SIZE;
+ }
+
+ @Override
+ public Size getMinSize() {
+ return CAPTURE_MIN_SIZE;
+ }
+
+ private static CaptureAreaAspectCalculation sInstance;
+
+ public synchronized static CaptureAreaAspectCalculation getInstance() {
+ if (sInstance == null) {
+ sInstance = new CaptureAreaAspectCalculation();
+ }
+ return sInstance;
+ }
+ }
+
+ static final class CompareAspectRatiosByDistanceToTargetRatio implements Comparator {
+ private Rational mTargetRatio;
+
+ CompareAspectRatiosByDistanceToTargetRatio(Rational targetRatio) {
+ mTargetRatio = targetRatio;
+ }
+
+ @Override
+ public int compare(Rational lhs, Rational rhs) {
+ if (lhs.equals(rhs)) {
+ return 0;
+ }
+
+ final Float lhsRatioDelta = Math.abs(lhs.floatValue() - mTargetRatio.floatValue());
+ final Float rhsRatioDelta = Math.abs(rhs.floatValue() - mTargetRatio.floatValue());
+
+ int result = (int) Math.signum(lhsRatioDelta - rhsRatioDelta);
+ return result;
+ }
+ }
+
+ static final class CompareSizesByArea implements Comparator {
+ private boolean mReverse = false;
+
+ CompareSizesByArea() {
+ }
+
+ CompareSizesByArea(boolean reverse) {
+ mReverse = reverse;
+ }
+
+ @Override
+ public int compare(Size lhs, Size rhs) {
+ int result =
+ Long.signum(
+ (long) lhs.getWidth() * lhs.getHeight()
+ - (long) rhs.getWidth() * rhs.getHeight());
+
+ if (mReverse) {
+ result *= -1;
+ }
+
+ return result;
+ }
+ }
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/ComboCameraErrorListener.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/ComboCameraErrorListener.java
new file mode 100644
index 000000000..f891bf14e
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/ComboCameraErrorListener.java
@@ -0,0 +1,33 @@
+package com.quark.quamera.camera.camera;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-21
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import java.util.List;
+
+public class ComboCameraErrorListener implements ICameraErrorListener {
+
+ private List mListeners;
+
+ public ComboCameraErrorListener(List listeners) {
+ mListeners = listeners;
+ }
+
+
+ @Override
+ public void onError(int cameraError, String message) {
+ if (mListeners == null) {
+ return;
+ }
+ for (ICameraErrorListener listener : mListeners) {
+ if (listener == null) {
+ continue;
+ }
+ listener.onError(cameraError, message);
+ }
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/ICameraErrorListener.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/ICameraErrorListener.java
new file mode 100644
index 000000000..f6a64752d
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/ICameraErrorListener.java
@@ -0,0 +1,13 @@
+package com.quark.quamera.camera.camera;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-21
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+public interface ICameraErrorListener {
+
+ void onError(int cameraError, String message);
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/ICameraStateListener.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/ICameraStateListener.java
new file mode 100644
index 000000000..21b18ac91
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/camera/ICameraStateListener.java
@@ -0,0 +1,12 @@
+package com.quark.quamera.camera.camera;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/6/6
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+public interface ICameraStateListener {
+ public void onCameraStateChanged(CameraState state);
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/concurrent/CameraExecutors.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/concurrent/CameraExecutors.java
new file mode 100644
index 000000000..72d82719f
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/concurrent/CameraExecutors.java
@@ -0,0 +1,52 @@
+package com.quark.quamera.camera.concurrent;
+
+import com.quark.quamera.util.SequentialExecutor;
+
+//package com.quark.quamera.camera.concurrent;
+///*
+// * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+// * Description :
+// *
+// * Creation : 20-11-23
+// * Author : jiaming.wjm@alibaba-inc.com
+// */
+//
+
+public class CameraExecutors {
+
+ private static SequentialExecutor sCameraTaskExecutor;
+
+ private static SequentialExecutor sImageAnalyzeSubscriptHandler;
+
+ public synchronized static SequentialExecutor getCameraTaskExecutor() {
+ return sCameraTaskExecutor;
+ }
+
+
+ public static synchronized void init() {
+ //do nothing
+ sCameraTaskExecutor = new SequentialExecutor("camera_executor");
+ sCameraTaskExecutor.start();
+
+ sImageAnalyzeSubscriptHandler = new SequentialExecutor("image_analyze");
+ sImageAnalyzeSubscriptHandler.start();
+ }
+
+ public synchronized static SequentialExecutor getImageAnalyzeSubscriptHandler() {
+ return sImageAnalyzeSubscriptHandler;
+ }
+
+
+ public static synchronized void unInit() {
+ if (sCameraTaskExecutor != null) {
+ sCameraTaskExecutor.stop();
+ sCameraTaskExecutor = null;
+ }
+ if (sImageAnalyzeSubscriptHandler != null) {
+ sImageAnalyzeSubscriptHandler.stop();
+ sImageAnalyzeSubscriptHandler = null;
+ }
+ }
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/concurrent/HandlerScheduledExecutorService.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/concurrent/HandlerScheduledExecutorService.java
new file mode 100644
index 000000000..63200fda6
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/concurrent/HandlerScheduledExecutorService.java
@@ -0,0 +1,106 @@
+package com.quark.quamera.camera.concurrent;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/2/8
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+
+import android.os.Handler;
+
+import androidx.annotation.NonNull;
+
+
+import com.quark.quamera.util.CameraShould;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.Delayed;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+public class HandlerScheduledExecutorService {
+ private final Handler mHandler;
+
+ public HandlerScheduledExecutorService(@NonNull Handler handler) {
+ mHandler = handler;
+ }
+
+
+ public ScheduledFuture schedule(Callable task, long delay_ms) {
+ HandlerScheduledFeature feature = new HandlerScheduledFeature<>(mHandler, delay_ms, task);
+ mHandler.postDelayed(feature, delay_ms);
+ return feature;
+ }
+
+ public static class HandlerScheduledFeature implements ScheduledFuture, Runnable {
+
+ private final long mRunAtMillis;
+ private boolean isCanceled;
+ private final Handler mHandler;
+ private final Callable mTask;
+ private boolean isDone;
+
+ public HandlerScheduledFeature(@NonNull Handler handler, long delayMs, @NonNull Callable task) {
+ mRunAtMillis = System.currentTimeMillis() + delayMs;
+ mHandler = handler;
+ mTask = task;
+ }
+
+ @Override
+ public long getDelay(TimeUnit unit) {
+ return unit.convert(mRunAtMillis - System.currentTimeMillis(),
+ TimeUnit.MILLISECONDS);
+ }
+
+ @Override
+ public int compareTo(Delayed o) {
+ return Long.compare(getDelay(TimeUnit.MILLISECONDS), o.getDelay(TimeUnit.MILLISECONDS));
+ }
+
+ @Override
+ public boolean cancel(boolean mayInterruptIfRunning) {
+ isCanceled = true;
+ mHandler.removeCallbacks(this);
+ return !isDone;
+ }
+
+ @Override
+ public boolean isCancelled() {
+ return isCanceled;
+ }
+
+ @Override
+ public boolean isDone() {
+ return isDone;
+ }
+
+ @Override
+ public T get() throws ExecutionException, InterruptedException {
+ CameraShould.fail("not support");
+ return null;
+ }
+
+ @Override
+ public T get(long timeout, TimeUnit unit) throws ExecutionException, InterruptedException, TimeoutException {
+ CameraShould.fail("not support");
+ return null;
+ }
+
+ @Override
+ public void run() {
+ if (isCanceled) {
+ return;
+ }
+ try {
+ mTask.call();
+ } catch (Exception e) {
+ CameraShould.fail();
+ }
+ isDone = true;
+ }
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/concurrent/MainThreadExecutor.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/concurrent/MainThreadExecutor.java
new file mode 100644
index 000000000..2d6240ee2
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/concurrent/MainThreadExecutor.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camera.concurrent;
+
+import android.os.Handler;
+import android.os.Looper;
+
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+
+/**
+ * Helper class for retrieving an {@link ScheduledExecutorService} which will post to the main
+ * thread.
+ *
+ * Since {@link ScheduledExecutorService} implements {@link Executor}, this can also be used
+ * as a simple Executor.
+ */
+public final class MainThreadExecutor implements Executor {
+ private static volatile MainThreadExecutor sInstance;
+
+ private final Handler mMainHandler;
+
+ private MainThreadExecutor() {
+ mMainHandler = new Handler(Looper.getMainLooper());
+ }
+
+ public static MainThreadExecutor getInstance() {
+ if (sInstance != null) {
+ return sInstance;
+ }
+ synchronized (MainThreadExecutor.class) {
+ sInstance = new MainThreadExecutor();
+ }
+
+ return sInstance;
+ }
+
+ @Override
+ public void execute(Runnable command) {
+ mMainHandler.post(command);
+ }
+
+}
\ No newline at end of file
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/imagereader/BlockImageAnalyzer.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/imagereader/BlockImageAnalyzer.java
new file mode 100644
index 000000000..0c25f9f05
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/imagereader/BlockImageAnalyzer.java
@@ -0,0 +1,11 @@
+package com.quark.quamera.camera.imagereader;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/4/22
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+class BlockImageAnalyzer {
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/imagereader/DeferrableImageReader.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/imagereader/DeferrableImageReader.java
new file mode 100644
index 000000000..f70a5dc4c
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/imagereader/DeferrableImageReader.java
@@ -0,0 +1,216 @@
+package com.quark.quamera.camera.imagereader;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-26
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.media.ImageReader;
+import android.os.Build;
+import android.os.Handler;
+
+import com.quark.quamera.camera.camera.CameraSurfaceHelper;
+import com.quark.quamera.camera.sensor.ImageRotationHelper;
+import com.quark.quamera.util.Preconditions;
+
+import java.util.concurrent.Executor;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+/**
+ * 延迟初始化话的ImageReader
+ * 核心解决ImageReader的宽高只有相机支持的才能生效，而当业务使用的时候，只能知道自己预期的宽高
+ */
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class DeferrableImageReader {
+
+ private int mExpectWidth;
+
+ private int mExpectHeight;
+
+ private int mActualWidth;
+
+ private int mActualHeight;
+
+ private final int mMaxImage;
+
+ private int mFormat;
+
+ private Handler mSubscriptHandler;
+
+ private ImageReader mImageReader;
+
+ private boolean mNonBlock = false;
+
+ private NoBlockImageAnalyzer mNoBlockImageAnalyzer;
+
+ private ImageRotationHelper mImageRotationHelper;
+
+ private CameraSurfaceHelper.ISuggestionCalculation mSizeCalculation = CameraSurfaceHelper.AreaClosestSizeCalculation.getInstance();
+
+
+ public static class Builder {
+
+ private int mExpectWidth;
+
+ private int mExpectHeight;
+
+ private Handler mSubscriptHandler;
+
+ private int mFormat;
+
+ private ImageAnalyzer mImageAnalyzer;
+
+ private Executor mHandlerExecutor;
+
+
+ private CameraSurfaceHelper.ISuggestionCalculation mSizeCalculation = CameraSurfaceHelper.AreaClosestSizeCalculation.getInstance();
+
+ public Builder setSizeCalculation(@NonNull CameraSurfaceHelper.ISuggestionCalculation sizeCalculation) {
+ mSizeCalculation = sizeCalculation;
+ return this;
+ }
+
+ public Builder setExpectWidth(int expectWidth) {
+ mExpectWidth = expectWidth;
+ return this;
+ }
+
+ public Builder setExpectHeight(int expectHeight) {
+ mExpectHeight = expectHeight;
+ return this;
+ }
+
+
+ public Builder setSubscriptHandler(Handler subscriptHandler) {
+ mSubscriptHandler = subscriptHandler;
+ return this;
+
+ }
+
+ public Builder setFormat(int format) {
+ mFormat = format;
+ return this;
+ }
+
+ public Builder setImageAnalyzer(ImageAnalyzer imageAnalyzer) {
+ mImageAnalyzer = imageAnalyzer;
+ return this;
+ }
+
+
+ public Builder setHandlerExecutor(Executor handlerExecutor) {
+ mHandlerExecutor = handlerExecutor;
+ return this;
+ }
+
+ public DeferrableImageReader build() {
+ Preconditions.checkState(mExpectWidth != 0);
+ Preconditions.checkState(mExpectHeight != 0);
+ Preconditions.checkState(mHandlerExecutor != null);
+ Preconditions.checkState(mFormat != 0);
+ return new DeferrableImageReader(
+ mExpectWidth, mExpectHeight, mFormat,
+ new NoBlockImageAnalyzer(mHandlerExecutor).setImageAnalyzer(mImageAnalyzer),
+ /**
+ * 在当前{@link NoBlockImageAnalyzer}的模式下，必须是3
+ * 1,用来消费接收
+ * 2.用来缓存
+ * 3.用来消费
+ */
+ 3,
+ mSubscriptHandler,
+ mSizeCalculation
+ );
+
+ }
+ }
+
+ private DeferrableImageReader(int expectWidth,
+ int expectHeight,
+ int format,
+ NoBlockImageAnalyzer analyzer,
+ int maxImage,
+ Handler subscriptHandler,
+ CameraSurfaceHelper.ISuggestionCalculation calculation
+ ) {
+ mExpectWidth = expectWidth;
+ mExpectHeight = expectHeight;
+ mFormat = format;
+ mMaxImage = maxImage;
+ mSubscriptHandler = subscriptHandler;
+ mNoBlockImageAnalyzer = analyzer;
+ mSizeCalculation = calculation;
+ }
+
+ public NoBlockImageAnalyzer getNoBlockImageAnalyzer() {
+ return mNoBlockImageAnalyzer;
+ }
+
+ public void closePipe() {
+ mNoBlockImageAnalyzer.close();
+ }
+
+ public void openPipe() {
+ mNoBlockImageAnalyzer.open();
+ }
+
+
+ public int getFormat() {
+ return mFormat;
+ }
+
+ public void createAndroidImageReader(int width, int height, ImageRotationHelper imageRotationHelper) {
+ mActualWidth = width;
+ mActualHeight = height;
+ mImageReader = ImageReader.newInstance(width, height, mFormat, mMaxImage);
+ mImageRotationHelper = imageRotationHelper;
+ mNoBlockImageAnalyzer.setImageRotationHelper(imageRotationHelper);
+ mImageReader.setOnImageAvailableListener(mNoBlockImageAnalyzer, mSubscriptHandler);
+ }
+
+
+ public ImageRotationHelper getImageRotationHelper() {
+ return mImageRotationHelper;
+ }
+
+ public ImageReader unWrapper() {
+ return mImageReader;
+ }
+
+ public int getExpectWidth() {
+ return mExpectWidth;
+ }
+
+ public int getExpectHeight() {
+ return mExpectHeight;
+ }
+
+ public int getActualWidth() {
+ return mActualWidth;
+ }
+
+ public int getActualHeight() {
+ return mActualHeight;
+ }
+
+ public void safeClose() {
+ //TODO 目前safeClose的逻辑没有生效，后续需要在所有Image处理完成之后，调用SafeClose
+ if (mImageReader != null) {
+ try {
+ mImageReader.close();
+ } catch (Exception e) {
+
+ }
+ mImageReader = null;
+ }
+ }
+
+ @NonNull
+ public CameraSurfaceHelper.ISuggestionCalculation getSizeCalculation() {
+ return mSizeCalculation;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/imagereader/ImageAnalyzer.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/imagereader/ImageAnalyzer.java
new file mode 100644
index 000000000..e1d87cb58
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/imagereader/ImageAnalyzer.java
@@ -0,0 +1,14 @@
+package com.quark.quamera.camera.imagereader;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-2
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.media.Image;
+
+public interface ImageAnalyzer {
+ public void analyze(Image image, int cameraSensorRotation, int imageRotation);
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/imagereader/NoBlockImageAnalyzer.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/imagereader/NoBlockImageAnalyzer.java
new file mode 100644
index 000000000..2eae5657c
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/imagereader/NoBlockImageAnalyzer.java
@@ -0,0 +1,167 @@
+package com.quark.quamera.camera.imagereader;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-2
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.media.Image;
+import android.media.ImageReader;
+import android.os.Build;
+
+import androidx.annotation.GuardedBy;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import com.quark.quamera.camera.sensor.ImageRotationHelper;
+import com.quark.quamera.util.Preconditions;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class NoBlockImageAnalyzer implements ImageReader.OnImageAvailableListener {
+
+ private Executor mExecutor;
+
+ private ImageAnalyzer mImageAnalyzer;
+
+ private ImageRotationHelper mImageRotationHelper;
+
+ public NoBlockImageAnalyzer(@NonNull Executor executor) {
+ Preconditions.checkState(executor != null);
+ mExecutor = executor;
+ }
+
+
+ public void setImageRotationHelper(@NonNull ImageRotationHelper imageRotationHelper) {
+ mImageRotationHelper = imageRotationHelper;
+ }
+
+ public enum State {
+ IDEAL,
+ WORKING,
+ }
+
+ public NoBlockImageAnalyzer setImageAnalyzer(ImageAnalyzer imageAnalyzer) {
+ mImageAnalyzer = imageAnalyzer;
+ return this;
+ }
+
+ @GuardedBy("mStateLock")
+ State mState = State.IDEAL;
+
+ final Object mStateLock = new Object();
+
+
+ @GuardedBy("mStateLock")
+ //producer data
+ private Image mCacheImage;
+
+ @GuardedBy("mStateLock")
+ //consumer data
+ private Image mWaitingProcessImg;
+
+ public boolean analyze(ImageReader reader) {
+ if (reader == null) {
+ return false;
+ }
+
+ //TEST
+ //TEST_RESULT : acquireLatestImage和close即使在低端机器上，也是不太耗时(acquire:1ms,close:7ms)
+ Image image = reader.acquireLatestImage();
+
+ if (image == null) {
+ return false;
+ }
+
+ if (mIsClose.get()) {
+ image.close();
+ return false;
+ }
+
+ //生产Image逻辑（后续如果复杂，将代码重构带Producer角色上）
+ synchronized (mStateLock) {
+ if (mState == State.IDEAL) {
+ mState = State.WORKING;
+ mWaitingProcessImg = image;
+ } else {
+ //更新最新Cache图片
+ if (mCacheImage != null) {
+ mCacheImage.close();
+ }
+ mCacheImage = image;
+ }
+ }
+
+ //有可能图片在等待执行，但是消息比较多，一直无法执行，导致将要执行的图片也cache，用于异常场景可以关闭
+ mExecutor.execute(() -> {
+
+
+ Image nextImg;
+
+ //消费Image逻辑（后续如果复杂，将代码重构到Consumer角色上）
+ synchronized (mStateLock) {
+ nextImg = mWaitingProcessImg;
+ mWaitingProcessImg = null;
+ }
+
+ if (mIsClose.get()) {
+ return;
+ }
+
+ while (nextImg != null) {
+ try {
+ if (mImageAnalyzer != null) {
+ mImageAnalyzer.analyze(
+ nextImg,
+ mImageRotationHelper != null ? mImageRotationHelper.getCameraSensorOrientation() : 0,
+ mImageRotationHelper != null ? mImageRotationHelper.getImageRotation() : 0
+ );
+ }
+ } finally {
+ nextImg.close();
+ }
+ synchronized (mStateLock) {
+ //get next cache
+ nextImg = mCacheImage;
+ mCacheImage = null;
+ }
+ }
+
+ synchronized (mStateLock) {
+ mState = State.IDEAL;
+ }
+ });
+
+ return true;
+ }
+
+ private AtomicBoolean mIsClose = new AtomicBoolean(false);
+
+ public void close() {
+ mIsClose.set(true);
+ synchronized (mStateLock) {
+ if (mCacheImage != null) {
+ mCacheImage.close();
+ mCacheImage = null;
+ }
+ if (mWaitingProcessImg != null) {
+ mWaitingProcessImg.close();
+ mWaitingProcessImg = null;
+ }
+ }
+ }
+
+ public void open() {
+ mIsClose.set(false);
+ }
+
+
+ @Override
+ public void onImageAvailable(ImageReader reader) {
+ analyze(reader);
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/IPreviewSurfaceProvider.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/IPreviewSurfaceProvider.java
new file mode 100644
index 000000000..d5ee7a1ab
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/IPreviewSurfaceProvider.java
@@ -0,0 +1,41 @@
+package com.quark.quamera.camera.preview;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-18
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.view.Surface;
+
+import com.quark.quamera.camera.camera.Camera2CameraImpl;
+import com.quark.quamera.camera.session.CameraCaptureComboCallback;
+
+import androidx.annotation.NonNull;
+import androidx.camera.core.Preview;
+
+public interface IPreviewSurfaceProvider {
+ default Surface provide(@NonNull SurfaceRequest request) {
+ return null;
+ }
+
+ default void onUseComplete(Surface surface) {
+
+ }
+
+ /**
+ * 只用于CameraX，共用接口
+ */
+ default Preview.SurfaceProvider providerSurface() {
+ return null;
+ }
+
+ class SurfaceRequest {
+ public int width;
+ public int height;
+ public Camera2CameraImpl camera2Camera;
+ public CameraCaptureComboCallback repeatCaptureCallback;
+
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/IPreviewView.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/IPreviewView.java
new file mode 100644
index 000000000..466723b34
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/IPreviewView.java
@@ -0,0 +1,50 @@
+package com.quark.quamera.camera.preview;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/7/12
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.graphics.RectF;
+import android.util.Rational;
+import android.util.Size;
+
+import androidx.camera.core.FocusMeteringResult;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.quark.quamera.render.photo.SnapShotCommand;
+
+public interface IPreviewView {
+
+ void doTakePhotoAnimation();
+
+ int getViewRotation();
+
+ @ViewPort.ScaleType
+ int getScaleType();
+
+ @Deprecated
+ Rational getAspectRatio();
+
+ int getViewHeight();
+
+ int getViewWidth();
+
+ /**
+ * 相机画面显示的区域，这个区域可能不是塞满整一个屏幕的
+ * 夸克的布局方式比较复杂，无法仅仅通过 scaleType 知道相机渲染的位置
+ */
+ RectF getCameraShowRect();
+
+ void updateCameraSurfaceSize(Size size);
+
+ Size getCameraSurfaceSize();
+
+ IPreviewSurfaceProvider getSurfaceProvider();
+
+ void snapshot(final SnapShotCommand snapShotCommand);
+
+ ListenableFuture autoFocus(float x, float y, float size, long autoCancelTime /*ms*/);
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/SurfaceTextureWrapper.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/SurfaceTextureWrapper.java
new file mode 100644
index 000000000..6993e50ac
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/SurfaceTextureWrapper.java
@@ -0,0 +1,135 @@
+package com.quark.quamera.camera.preview;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2020/4/15
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.graphics.SurfaceTexture;
+import android.util.Log;
+import android.view.Surface;
+
+import com.quark.quamera.util.CameraLogger;
+
+import java.util.Arrays;
+
+public class SurfaceTextureWrapper {
+ private SurfaceTexture mSurfaceTexture;
+ private Surface mSurface;
+
+ private volatile boolean mHasAttach;
+
+ private volatile boolean mHasRelease;
+
+ private int mAttachContextId = -1;
+
+ private int[] mSize = new int[2];
+
+
+ public synchronized void release() {
+ try {
+ if (mSurfaceTexture != null) {
+ mSurfaceTexture.release();
+ CameraLogger.i("SurfaceTexture", "release texture (%s)", this);
+ }
+ } catch (Exception ignore) {
+ } finally {
+ mHasRelease = true;
+ }
+ }
+
+
+ public SurfaceTextureWrapper(int width, int height) {
+ mSize[0] = width;
+ mSize[1] = height;
+ mSurfaceTexture = new SurfaceTexture(0);
+ mSurfaceTexture.setDefaultBufferSize(width, height);
+ mSurfaceTexture.detachFromGLContext();
+ mSurface = new Surface(mSurfaceTexture);
+ }
+
+ public synchronized boolean isValid() {
+ return !mHasRelease;
+ }
+
+ public synchronized SurfaceTexture getSurfaceTexture() {
+ return mSurfaceTexture;
+ }
+
+ public synchronized boolean updateTexImage() {
+ if (mHasRelease) {
+ return false;
+ }
+ mSurfaceTexture.updateTexImage();
+ return true;
+ }
+
+ public synchronized void getTransformMatrix(float[] mat) {
+ if (mHasRelease) {
+ return;
+ }
+ mSurfaceTexture.getTransformMatrix(mat);
+ }
+
+ public synchronized boolean attachToGLContext(int context_id, int attach_texture_id) {
+ if (mHasRelease) {
+ return false;
+ }
+ if (mHasAttach && mAttachContextId == context_id) {
+ return true;
+ }
+
+ if (mHasAttach) {
+ mSurfaceTexture.detachFromGLContext();
+ }
+
+ long start = System.nanoTime();
+ mSurfaceTexture.attachToGLContext(attach_texture_id);
+
+
+ CameraLogger.testLongLog("SurfaceTexture", "attachToGLContext texture:%d, (use:%d) Object:%s ",
+ attach_texture_id, (System.nanoTime() - start) / 1000000, this.toString());
+
+ mHasAttach = true;
+ mAttachContextId = context_id;
+ return true;
+ }
+
+ public synchronized void detachFromGLContext(int context_id) {
+ if (mHasRelease) {
+ return;
+ }
+ if (mHasAttach && mAttachContextId == context_id) {
+ long start = System.nanoTime();
+ mSurfaceTexture.detachFromGLContext();
+
+ CameraLogger.testLongLog("SurfaceTexture", "detachFromGLContext (use:%d) Object:%s ",
+ (System.nanoTime() - start) / 1000000, this.toString());
+
+ mAttachContextId = -1;
+ mHasAttach = false;
+ }
+ }
+
+ public Surface getSurface() {
+ return mSurface;
+ }
+
+ public int[] getSize() {
+ return mSize;
+ }
+
+
+ @Override
+ public String toString() {
+ return "SurfaceTextureWrapper{" +
+ "mSurfaceTexture=" + mSurfaceTexture +
+ ", mHasAttach=" + mHasAttach +
+ ", mHasRelease=" + mHasRelease +
+ ", mAttachContextId=" + mAttachContextId +
+ ", mSize=" + Arrays.toString(mSize) +
+ '}';
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/ViewPort.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/ViewPort.java
new file mode 100644
index 000000000..14aab0f56
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/ViewPort.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camera.preview;
+
+import android.view.Surface;
+import android.view.SurfaceView;
+
+import androidx.annotation.IntDef;
+import androidx.annotation.RestrictTo;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+
+public final class ViewPort {
+
+ /**
+ * LayoutDirection that defines the start and end of the {@link ScaleType}.
+ *
+ * @hide
+ * @see android.util.LayoutDirection
+ */
+ @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+ @IntDef({android.util.LayoutDirection.LTR, android.util.LayoutDirection.RTL})
+ @Retention(RetentionPolicy.SOURCE)
+ public @interface LayoutDirection {
+ }
+
+ /**
+ * Scale types used to calculate the crop rect for a {@link UseCase}.
+ *
+ * @hide
+ */
+ @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+ @IntDef({FILL_START, FILL_CENTER, FILL_END, FIT, CENTER_INSIDE})
+ @Retention(RetentionPolicy.SOURCE)
+ public @interface ScaleType {
+ }
+
+ /**
+ * Generate a crop rect that once applied, it scales the output while maintaining its aspect
+ * ratio, so it fills the entire {@link ViewPort}, and align it to the start of the
+ * {@link ViewPort}, which is the top left corner in a left-to-right (LTR) layout, or the top
+ * right corner in a right-to-left (RTL) layout.
+ *
+ * This may cause the output to be cropped if the output aspect ratio does not match that of
+ * the {@link ViewPort}.
+ */
+ public static final int FILL_START = 0;
+
+ /**
+ * Generate a crop rect that once applied, it scales the output while maintaining its aspect
+ * ratio, so it fills the entire {@link ViewPort} and center it.
+ *
+ * This may cause the output to be cropped if the output aspect ratio does not match that of
+ * the {@link ViewPort}.
+ */
+ public static final int FILL_CENTER = 1;
+
+ /**
+ * Generate a crop rect that once applied, it scales the output while maintaining its aspect
+ * ratio, so it fills the entire {@link ViewPort}, and align it to the end of the
+ * {@link ViewPort}, which is the bottom right corner in a left-to-right (LTR) layout, or the
+ * bottom left corner in a right-to-left (RTL) layout.
+ *
+ * This may cause the output to be cropped if the output aspect ratio does not match that of
+ * the {@link ViewPort}.
+ */
+ public static final int FILL_END = 2;
+
+ /**
+ * Generate the max possible crop rect ignoring the aspect ratio. For {@link ImageAnalysis}
+ * and {@link ImageCapture}, the output will be an image defined by the crop rect.
+ *
+ *
For {@link Preview}, further calculation is needed to to fit the crop rect into the
+ * viewfinder. Code sample below is a simplified version assuming {@link Surface}
+ * orientation is the same as the camera sensor orientation, the viewfinder is a
+ * {@link SurfaceView} and the viewfinder's pixel width/height is the same as the size
+ * request by CameraX in {@link SurfaceRequest#getResolution()}. For more complicated
+ * scenarios, please check out the source code of PreviewView in androidx.camera.view artifact.
+ *
+ *
First, calculate the transformation to fit the crop rect in the center of the viewfinder:
+ *
+ *
{@code
+ * val transformation = Matrix()
+ * transformation.setRectToRect(
+ * cropRect, new RectF(0, 0, viewFinder.width, viewFinder.height, ScaleToFit.CENTER))
+ * }
+ *
+ * Then apply the transformation to the viewfinder:
+ *
+ *
{@code
+ * val transformedRect = RectF(0, 0, viewFinder.width, viewFinder.height)
+ * transformation.mapRect(surfaceRect)
+ * viewFinder.pivotX = 0
+ * viewFinder.pivotY = 0
+ * viewFinder.translationX = transformedRect.left
+ * viewFinder.translationY = transformedRect.top
+ * viewFinder.scaleX = surfaceRect.width/transformedRect.width
+ * viewFinder.scaleY = surfaceRect.height/transformedRect.height
+ * }
+ */
+ public static final int FIT = 3;
+
+
+ public static final int CENTER_INSIDE = 4;
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/ViewPorts.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/ViewPorts.java
new file mode 100644
index 000000000..ed65aadf7
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/preview/ViewPorts.java
@@ -0,0 +1,304 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camera.preview;
+
+import android.annotation.SuppressLint;
+import android.graphics.Matrix;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.os.Build;
+import android.util.LayoutDirection;
+import android.util.Rational;
+import android.util.Size;
+
+import androidx.annotation.IntRange;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import com.quark.quamera.util.CameraLogger;
+import com.quark.quamera.util.CameraShould;
+import com.quark.quamera.util.ImageUtils;
+
+/**
+ * Utility methods for calculating viewports.
+ */
+public class ViewPorts {
+ private ViewPorts() {
+
+ }
+
+ /**
+ * Calculate a set of ViewPorts based on the combination of the camera, viewport, and use cases.
+ *
+ * This method calculates the crop rect for each use cases. It only thinks in abstract terms
+ * like the original dimension, output rotation and desired crop rect expressed via viewport.
+ * It does not care about the use case types or the device/display rotation.
+ *
+ * @param fullSensorRect The full size of the viewport.
+ * @param viewPortAspectRatio The aspect ratio of the viewport.
+ * @param outputRotationDegrees Clockwise rotation to correct the surfaces to display
+ * rotation.
+ * @param scaleType The scale type to calculate
+ * @param layoutDirection The direction of layout.
+ * @param surfaceOutResolution The resolutions of the UseCases
+ * @return The set of Viewports that should be set for each UseCase
+ */
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ @NonNull
+ public static Rect calculateViewPortRect(
+ @NonNull Rect fullSensorRect,
+ boolean isFrontCamera,
+ @NonNull Rational viewPortAspectRatio,
+ @IntRange(from = 0, to = 359) int outputRotationDegrees,
+ @ViewPort.ScaleType int scaleType,
+ @ViewPort.LayoutDirection int layoutDirection,
+ @NonNull Size surfaceOutResolution) {
+ CameraShould.beTrue(
+ fullSensorRect.width() > 0 && fullSensorRect.height() > 0,
+ "Cannot compute viewport crop rects zero sized sensor rect.");
+
+ CameraLogger.i("ViewPorts", "calculateViewPortRect { \n\t\t fullSensorRect:%s \n\t\t isFrontCamera:%b " +
+ "\n\t\t viewPortAspectRatio:%s \n\t\t outputRotationDegrees:%d \n\t\t scaleType:%d \n\t\t " +
+ "surfaceOutResolution:%s \n}", fullSensorRect, isFrontCamera, viewPortAspectRatio,
+ outputRotationDegrees, scaleType, surfaceOutResolution);
+
+ // The key to calculate the crop rect is that all the crop rect should match to the same
+ // region on camera sensor. This method first calculates the shared camera region, and then
+ // maps it use cases to find out their crop rects.
+
+ // Calculate the mapping between sensor buffer and UseCases, and the sensor rect shared
+ // by all use cases.
+ RectF fullSensorRectF = new RectF(fullSensorRect);
+ RectF sensorIntersectionRect = new RectF(fullSensorRect);
+ // Calculate the transformation from UseCase to sensor.
+ Matrix useCaseToSensorTransformation = new Matrix();
+ RectF srcRect = new RectF(0, 0, surfaceOutResolution.getWidth(),
+ surfaceOutResolution.getHeight());
+ useCaseToSensorTransformation.setRectToRect(srcRect, fullSensorRectF,
+ Matrix.ScaleToFit.CENTER);
+// useCaseToSensorTransformations.put(entry.getKey(), useCaseToSensorTransformation);
+
+ // Calculate the UseCase intersection in sensor coordinates.
+ RectF useCaseSensorRect = new RectF();
+ useCaseToSensorTransformation.mapRect(useCaseSensorRect, srcRect);
+ sensorIntersectionRect.intersect(useCaseSensorRect);
+
+ // Crop the shared sensor rect based on viewport parameters.
+ Rational rotatedViewPortAspectRatio = ImageUtils.getRotatedAspectRatio(
+ outputRotationDegrees, viewPortAspectRatio);
+ RectF viewPortRect = getScaledRect(
+ sensorIntersectionRect, rotatedViewPortAspectRatio, scaleType, isFrontCamera,
+ layoutDirection, outputRotationDegrees);
+
+ // Map the cropped shared sensor rect to UseCase coordinates.
+ RectF useCaseOutputRect = new RectF();
+ Matrix sensorToUseCaseTransformation = new Matrix();
+ // Transform the sensor crop rect to UseCase coordinates.
+ useCaseToSensorTransformation.invert(sensorToUseCaseTransformation);
+ sensorToUseCaseTransformation.mapRect(useCaseOutputRect, viewPortRect);
+ Rect outputCropRect = new Rect();
+ useCaseOutputRect.round(outputCropRect);
+ return outputCropRect;
+ }
+
+ /**
+ * Returns the container rect that the given rect fills.
+ *
+ *
For FILL types, returns the largest container rect that is smaller than the view port.
+ * The returned rectangle is also required to 1) have the view port's aspect ratio and 2) be
+ * in the surface coordinates.
+ *
+ *
For FIT, returns the largest possible rect shared by all use cases.
+ */
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ @SuppressLint("SwitchIntDef")
+ @NonNull
+ public static RectF getScaledRect(
+ @NonNull RectF fittingRect,
+ @NonNull Rational containerAspectRatio,
+ @ViewPort.ScaleType int scaleType,
+ boolean isFrontCamera,
+ @ViewPort.LayoutDirection int layoutDirection,
+ @IntRange(from = 0, to = 359) int rotationDegrees) {
+ if (scaleType == ViewPort.FIT) {
+ // Return the fitting rect if the rect is fully covered by the container.
+ return fittingRect;
+ }
+ // Using Matrix' convenience methods fill the rect into the containing rect with given
+ // aspect ratio.
+ // NOTE: By using the Matrix#setRectToRect, we assume the "start" is always (0, 0) and
+ // the "end" is always (w, h), which is NOT always true depending on rotation, layout
+ // orientation and/or camera lens facing. We need to correct the rect based on rotation and
+ // layout direction.
+ Matrix viewPortToSurfaceTransformation = new Matrix();
+ RectF viewPortRect = new RectF(0, 0, containerAspectRatio.getNumerator(),
+ containerAspectRatio.getDenominator());
+ switch (scaleType) {
+ case ViewPort.FILL_CENTER:
+ viewPortToSurfaceTransformation.setRectToRect(
+ viewPortRect, fittingRect, Matrix.ScaleToFit.CENTER);
+ break;
+ case ViewPort.FILL_START:
+ viewPortToSurfaceTransformation.setRectToRect(
+ viewPortRect, fittingRect, Matrix.ScaleToFit.START);
+ break;
+ case ViewPort.FILL_END:
+ viewPortToSurfaceTransformation.setRectToRect(
+ viewPortRect, fittingRect, Matrix.ScaleToFit.END);
+ break;
+ case ViewPort.CENTER_INSIDE:
+ //not crop
+ viewPortToSurfaceTransformation.setRectToRect(
+ fittingRect, fittingRect, Matrix.ScaleToFit.FILL);
+ break;
+ default:
+ throw new IllegalStateException("Unexpected scale type: " + scaleType);
+ }
+
+ RectF viewPortRectInSurfaceCoordinates = new RectF();
+ viewPortToSurfaceTransformation.mapRect(viewPortRectInSurfaceCoordinates, viewPortRect);
+
+ // Correct the crop rect based on rotation and layout direction.
+ return correctStartOrEnd(
+ shouldMirrorStartAndEnd(isFrontCamera, layoutDirection),
+ rotationDegrees,
+ fittingRect,
+ viewPortRectInSurfaceCoordinates);
+ }
+
+ /**
+ * Correct viewport based on rotation and layout direction.
+ *
+ *
Both rotation and mirroring change the definition of the "start" and "end" in
+ * scale type. For rotation, since the value is clockwise rotation should be applied to the
+ * output buffer, the start/end point should be rotated counterclockwisely. If mirroring is
+ * needed, the start/end point should be mirrored based on the upright direction of the
+ * image.
+ */
+ private static RectF correctStartOrEnd(boolean isMirrored,
+ @IntRange(from = 0, to = 359) int rotationDegrees,
+ RectF containerRect,
+ RectF cropRect) {
+ // For each scenario there is an illustration of the output buffer without correction.
+ // The arrow represents the opposite direction of gravity. The start/end point should
+ // rotate counterclockwisely based on rotationDegrees, and mirror along the line of the
+ // arrow if mirroring is needed.
+
+ //
+ // Start +-----+
+ // | ^ |
+ // +-----+ End
+ //
+ boolean ltrRotation0 = rotationDegrees == 0 && !isMirrored;
+ //
+ // Start +-----+ 90° +-----+ End Mirrored Start +-----+
+ // | ^ | ===> | < | ==> | < |
+ // +-----+ End Start +-----+ +-----+ End
+ //
+ boolean rtlRotation90 = rotationDegrees == 90 && isMirrored;
+ if (ltrRotation0 || rtlRotation90) {
+ return cropRect;
+ }
+
+ //
+ // Start +-----+ Mirrored +-----+ Start
+ // | ^ | ===> | ^ |
+ // +-----+ End End +-----+
+ //
+ boolean rtlRotation0 = rotationDegrees == 0 && isMirrored;
+ //
+ // Start +-----+ 270° +-----+ Start
+ // | ^ | ===> | > |
+ // +-----+ End End +-----+
+ //
+ boolean ltrRotation270 = rotationDegrees == 270 && !isMirrored;
+ if (rtlRotation0 || ltrRotation270) {
+ return flipHorizontally(cropRect, containerRect.centerX());
+ }
+
+ //
+ // Start +-----+ 90° +-----+ End
+ // | ^ | ===> | < |
+ // +-----+ End Start +-----+
+ //
+ boolean ltrRotation90 = rotationDegrees == 90 && !isMirrored;
+ //
+ // Start +-----+ 180° End +-----+ Mirrored +-----+ End
+ // | ^ | ===> | v | ==> | v |
+ // +-----+ End +-----+ Start Start +-----+
+ //
+ boolean rtlRotation180 = rotationDegrees == 180 && isMirrored;
+ if (ltrRotation90 || rtlRotation180) {
+ return flipVertically(cropRect, containerRect.centerY());
+ }
+
+ //
+ // Start +-----+ 180° End +-----+
+ // | ^ | ===> | v |
+ // +-----+ End +-----+ Start
+ //
+ boolean ltrRotation180 = rotationDegrees == 180 && !isMirrored;
+ //
+ // Start +-----+ 270° +-----+ Start Mirrored End +-----+
+ // | ^ | ===> | > | ==> | > |
+ // +-----+ End End +-----+ +-----+ Start
+ //
+ boolean rtlRotation270 = rotationDegrees == 270 && isMirrored;
+ if (ltrRotation180 || rtlRotation270) {
+ return flipHorizontally(flipVertically(cropRect, containerRect.centerY()),
+ containerRect.centerX());
+ }
+
+ throw new IllegalArgumentException("Invalid argument: mirrored " + isMirrored + " "
+ + "rotation " + rotationDegrees);
+ }
+
+ /**
+ * Checks if the start/end direction in scale type should be mirrored.
+ *
+ *
They should be mirrored if one and only one of the following is true: the front camera is
+ * used or layout direction is RTL.
+ */
+ private static boolean shouldMirrorStartAndEnd(boolean isFrontCamera,
+ @ViewPort.LayoutDirection int layoutDirection) {
+ return isFrontCamera ^ layoutDirection == LayoutDirection.RTL;
+ }
+
+ private static RectF flipHorizontally(RectF original, float flipLineX) {
+ return new RectF(
+ flipX(original.right, flipLineX),
+ original.top,
+ flipX(original.left, flipLineX),
+ original.bottom);
+ }
+
+ private static RectF flipVertically(RectF original, float flipLineY) {
+ return new RectF(
+ original.left,
+ flipY(original.bottom, flipLineY),
+ original.right,
+ flipY(original.top, flipLineY));
+ }
+
+ private static float flipX(float x, float flipLineX) {
+ return flipLineX + flipLineX - x;
+ }
+
+ private static float flipY(float y, float flipLineY) {
+ return flipLineY + flipLineY - y;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/sensor/CameraOrientationUtil.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/sensor/CameraOrientationUtil.java
new file mode 100644
index 000000000..718587a11
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/sensor/CameraOrientationUtil.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camera.sensor;
+
+import android.util.Log;
+import android.view.Surface;
+
+import androidx.annotation.RestrictTo;
+import androidx.annotation.RestrictTo.Scope;
+
+import com.quark.quamera.camera.session.CameraSelector;
+
+/**
+ * Contains utility methods related to camera orientation.
+ *
+ * @hide
+ */
+@RestrictTo(Scope.LIBRARY_GROUP)
+public final class CameraOrientationUtil {
+ private static final String TAG = "CameraOrientationUtil";
+ private static final boolean DEBUG = false;
+
+ // Do not allow instantiation
+ private CameraOrientationUtil() {
+ }
+
+ /**
+ * Calculates the delta between a source rotation and destination rotation.
+ *
+ *
A typical use of this method would be calculating the angular difference between the
+ * display orientation (destRotationDegrees) and camera sensor orientation
+ * (sourceRotationDegrees).
+ *
+ * @param destRotationDegrees The destination rotation relative to the device's natural
+ * rotation.
+ * @param sourceRotationDegrees The source rotation relative to the device's natural rotation.
+ * @param isOppositeFacing Whether the source and destination planes are facing opposite
+ * directions.
+ */
+ public static int getRelativeImageRotation(
+ int destRotationDegrees, int sourceRotationDegrees, boolean isOppositeFacing) {
+ int result;
+ if (isOppositeFacing) {
+ result = (sourceRotationDegrees - destRotationDegrees + 360) % 360;
+ } else {
+ result = (sourceRotationDegrees + destRotationDegrees) % 360;
+ }
+ if (DEBUG) {
+ Log.d(
+ TAG,
+ String.format(
+ "getRelativeImageRotation: destRotationDegrees=%s, "
+ + "sourceRotationDegrees=%s, isOppositeFacing=%s, "
+ + "result=%s",
+ destRotationDegrees, sourceRotationDegrees, isOppositeFacing, result));
+ }
+ return result;
+ }
+
+ /**
+ * Converts rotation values enumerated in {@link Surface} to their equivalent in degrees.
+ *
+ *
Valid values for the relative rotation are {@link Surface#ROTATION_0}, {@link
+ * Surface#ROTATION_90}, {@link Surface#ROTATION_180}, {@link Surface#ROTATION_270}.
+ *
+ * @param rotationEnum One of the enumerated rotation values from {@link Surface}.
+ * @return The equivalent rotation value in degrees.
+ * @throws IllegalArgumentException If the provided rotation enum is not one of those defined in
+ * {@link Surface}.
+ */
+ public static int surfaceRotationToDegrees(int rotationEnum) {
+ int rotationDegrees;
+ switch (rotationEnum) {
+ case Surface.ROTATION_0:
+ rotationDegrees = 0;
+ break;
+ case Surface.ROTATION_90:
+ rotationDegrees = 90;
+ break;
+ case Surface.ROTATION_180:
+ rotationDegrees = 180;
+ break;
+ case Surface.ROTATION_270:
+ rotationDegrees = 270;
+ break;
+ default:
+ throw new IllegalArgumentException("Unsupported surface rotation: " + rotationEnum);
+ }
+
+ return rotationDegrees;
+ }
+
+ /**
+ * 用户视觉上图片旋转角度
+ */
+ public static int getCameraImageRotation(CameraSelector.CameraLenFacing lenFacing, int cameraSensorRotation, int displaySensorRotation) {
+ int rotation = lenFacing == CameraSelector.CameraLenFacing.LEN_FACING_BACK ? (360 - displaySensorRotation)
+ : displaySensorRotation;
+ return (cameraSensorRotation + rotation) % 360;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/sensor/DisplayOrientationDetector.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/sensor/DisplayOrientationDetector.java
new file mode 100644
index 000000000..60a54f7ac
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/sensor/DisplayOrientationDetector.java
@@ -0,0 +1,141 @@
+package com.quark.quamera.camera.sensor;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-14
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.content.Context;
+import android.view.OrientationEventListener;
+
+import com.quark.quamera.util.CameraInit;
+import com.quark.quamera.util.CameraLogger;
+import com.quark.quamera.util.CollectionUtil;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * TODO: 目前来看,OrientationEventListener的灵敏度不太够
+ *
+ * TODO: 后续基于磁场，重力传感器，实现灵命的横竖屏感应
+ */
+public class DisplayOrientationDetector extends OrientationEventListener implements IOrientationDetector {
+
+
+ private final AtomicInteger mDeviceNatureRotation = new AtomicInteger();
+
+ private final List> mListeners;
+
+ private final String mTag;
+
+ private boolean enableRotate;
+
+ public DisplayOrientationDetector(Context context, String tag) {
+ super(context);
+ mTag = tag;
+ mListeners = new ArrayList<>();
+ enableRotate = true;
+ }
+
+ /**
+ * 注意是虚引用
+ */
+ public synchronized void addListener(OrientChangeListener listener) {
+ mListeners.add(new WeakReference<>(listener));
+ }
+
+ public synchronized void removeListener(OrientChangeListener listener) {
+ Iterator> it = mListeners.iterator();
+ while (it.hasNext()) {
+ WeakReference ref = it.next();
+ OrientChangeListener l = ref.get();
+ if (l == null) {
+ it.remove();
+ continue;
+ }
+
+ if (l == listener) {
+ it.remove();
+ }
+ }
+ }
+
+ private final AtomicInteger mStartCount = new AtomicInteger();
+
+ public void start() {
+ if (super.canDetectOrientation()) {
+ CameraLogger.i(mTag, "start display orientation detect");
+ super.enable();
+ }
+ }
+
+ public void stop() {
+ CameraLogger.i(mTag, "stop display orientation detect");
+ super.disable();
+ }
+
+ public void forceQuit() {
+ CameraLogger.i(mTag, "force stop display orientation detect");
+ super.disable();
+ }
+
+ public synchronized void clearAllListeners() {
+ mListeners.clear();
+ }
+
+ @Override
+ public void onOrientationChanged(int orientation) {
+ if (!enableRotate) {
+ return;
+ }
+ if (orientation == OrientationEventListener.ORIENTATION_UNKNOWN) {
+ return;
+ }
+ int newOrientation = ((orientation + 45) / 90 * 90) % 360;
+ // As "getDefaultDisplay().getRotation()" is counter-clockwise, but sensor is clockwise
+ if (newOrientation == 90) {
+ newOrientation = 270;
+ } else if (newOrientation == 270) {
+ newOrientation = 90;
+ }
+ if (newOrientation != mDeviceNatureRotation.get()) {
+ if (CameraInit.getConfig().isDebuggable()) {
+ CameraLogger.i(mTag, "display orientation changed " + newOrientation);
+ }
+
+ mDeviceNatureRotation.set(newOrientation);
+ synchronized (DisplayOrientationDetector.this) {
+ CollectionUtil.forEach(mListeners, ref -> {
+ OrientChangeListener l = ref.get();
+ if (l != null) {
+ l.onOrientationChanged(mDeviceNatureRotation);
+ }
+ });
+ }
+ }
+ }
+
+ public AtomicInteger getDeviceDisplayRotation() {
+ return mDeviceNatureRotation;
+ }
+
+ public void setEnableRotate(final boolean enableRotate) {
+ if (!enableRotate) {
+ synchronized (DisplayOrientationDetector.this) {
+ CollectionUtil.forEach(mListeners, ref -> {
+ OrientChangeListener l = ref.get();
+ if (l != null) {
+ l.onOrientationChanged(new AtomicInteger(0));
+ }
+ });
+ }
+ }
+ this.enableRotate = enableRotate;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/sensor/IOrientationDetector.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/sensor/IOrientationDetector.java
new file mode 100644
index 000000000..db20fda10
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/sensor/IOrientationDetector.java
@@ -0,0 +1,21 @@
+package com.quark.quamera.camera.sensor;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-14
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public interface IOrientationDetector {
+ public void addListener(OrientChangeListener listener);
+
+ public void removeListener(OrientChangeListener listener);
+
+ interface OrientChangeListener {
+ public void onOrientationChanged(AtomicInteger orientation);
+ }
+}
+
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/sensor/ImageRotationHelper.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/sensor/ImageRotationHelper.java
new file mode 100644
index 000000000..439923d14
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/sensor/ImageRotationHelper.java
@@ -0,0 +1,64 @@
+package com.quark.quamera.camera.sensor;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-14
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.os.Build;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import com.quark.quamera.camera.camera.Camera2Info;
+import com.quark.quamera.camera.session.CameraSelector;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+
+public class ImageRotationHelper {
+ private final DisplayOrientationDetector mDisplayOrientationDetector;
+ private final CameraSelector.CameraLenFacing mLenFacing;
+ private final int mCameraSensorOrientation;
+
+
+ public ImageRotationHelper(@NonNull Camera2Info camera2Info, @NonNull DisplayOrientationDetector displayOrientationHelper) {
+ mDisplayOrientationDetector = displayOrientationHelper;
+ mLenFacing = camera2Info.getCameraLenFacing();
+ mCameraSensorOrientation = camera2Info.getSensorOrientation();
+ }
+
+ /**
+ * 相机传感器的旋转角度
+ * 通常情况下：
+ * 前置：90
+ * 后置：270
+ */
+ public int getCameraSensorOrientation() {
+ return mCameraSensorOrientation;
+ }
+
+ /**
+ * 屏幕本身的旋转角度(顺时针旋转)
+ *
+ * 0 ：竖直屏幕的自然方向
+ * 90 ：
+ * 180：
+ * 270：
+ */
+ public int getDeviceRotation() {
+ return mDisplayOrientationDetector.getDeviceDisplayRotation().get();
+ }
+
+ /**
+ * 相机原始纹理，拍正到用户自然角度，纹理需要旋转的角度
+ */
+ public int getImageRotation() {
+ return CameraOrientationUtil.getCameraImageRotation(
+ mLenFacing,
+ mCameraSensorOrientation,
+ mDisplayOrientationDetector.getDeviceDisplayRotation().get()
+ );
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/Camera2CameraCaptureResult.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/Camera2CameraCaptureResult.java
new file mode 100644
index 000000000..02f686b49
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/Camera2CameraCaptureResult.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camera.session;
+
+import android.hardware.camera2.CaptureResult;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+
+import com.quark.quamera.camera.session.CameraCaptureMetaData.AeState;
+import com.quark.quamera.camera.session.CameraCaptureMetaData.AfMode;
+import com.quark.quamera.camera.session.CameraCaptureMetaData.AfState;
+import com.quark.quamera.camera.session.CameraCaptureMetaData.AwbState;
+import com.quark.quamera.camera.session.CameraCaptureMetaData.FlashState;
+
+/**
+ * The camera2 implementation for the capture result of a single image capture.
+ */
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+final class Camera2CameraCaptureResult implements CameraCaptureResult {
+ private static final String TAG = "C2CameraCaptureResult";
+
+ private final Object mTag;
+
+ /**
+ * The actual camera2 {@link CaptureResult}.
+ */
+ private final CaptureResult mCaptureResult;
+
+ Camera2CameraCaptureResult(@Nullable Object tag, CaptureResult captureResult) {
+ mTag = tag;
+ mCaptureResult = captureResult;
+ }
+
+ /**
+ * Converts the camera2 {@link CaptureResult#CONTROL_AF_MODE} to {@link AfMode}.
+ *
+ * @return the {@link AfMode}.
+ */
+ @NonNull
+ @Override
+ public AfMode getAfMode() {
+ Integer mode = mCaptureResult.get(CaptureResult.CONTROL_AF_MODE);
+ if (mode == null) {
+ return AfMode.UNKNOWN;
+ }
+ switch (mode) {
+ case CaptureResult.CONTROL_AF_MODE_OFF:
+ case CaptureResult.CONTROL_AF_MODE_EDOF:
+ return AfMode.OFF;
+ case CaptureResult.CONTROL_AF_MODE_AUTO:
+ case CaptureResult.CONTROL_AF_MODE_MACRO:
+ return AfMode.ON_MANUAL_AUTO;
+ case CaptureResult.CONTROL_AF_MODE_CONTINUOUS_PICTURE:
+ case CaptureResult.CONTROL_AF_MODE_CONTINUOUS_VIDEO:
+ return AfMode.ON_CONTINUOUS_AUTO;
+ default: // fall out
+ }
+ Log.e(TAG, "Undefined af mode: " + mode);
+ return AfMode.UNKNOWN;
+ }
+
+ /**
+ * Converts the camera2 {@link CaptureResult#CONTROL_AF_STATE} to {@link AfState}.
+ *
+ * @return the {@link AfState}.
+ */
+ @NonNull
+ @Override
+ public AfState getAfState() {
+ Integer state = mCaptureResult.get(CaptureResult.CONTROL_AF_STATE);
+ if (state == null) {
+ return AfState.UNKNOWN;
+ }
+ switch (state) {
+ case CaptureResult.CONTROL_AF_STATE_INACTIVE:
+ return AfState.INACTIVE;
+ case CaptureResult.CONTROL_AF_STATE_ACTIVE_SCAN:
+ case CaptureResult.CONTROL_AF_STATE_PASSIVE_SCAN:
+ case CaptureResult.CONTROL_AF_STATE_PASSIVE_UNFOCUSED:
+ return AfState.SCANNING;
+ case CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED:
+ return AfState.LOCKED_FOCUSED;
+ case CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
+ return AfState.LOCKED_NOT_FOCUSED;
+ case CaptureResult.CONTROL_AF_STATE_PASSIVE_FOCUSED:
+ return AfState.FOCUSED;
+ default: // fall out
+ }
+ Log.e(TAG, "Undefined af state: " + state);
+ return AfState.UNKNOWN;
+ }
+
+ /**
+ * Converts the camera2 {@link CaptureResult#CONTROL_AE_STATE} to {@link AeState}.
+ *
+ * @return the {@link AeState}.
+ */
+ @NonNull
+ @Override
+ public AeState getAeState() {
+ Integer state = mCaptureResult.get(CaptureResult.CONTROL_AE_STATE);
+ if (state == null) {
+ return AeState.UNKNOWN;
+ }
+ switch (state) {
+ case CaptureResult.CONTROL_AE_STATE_INACTIVE:
+ return AeState.INACTIVE;
+ case CaptureResult.CONTROL_AE_STATE_SEARCHING:
+ case CaptureResult.CONTROL_AE_STATE_PRECAPTURE:
+ return AeState.SEARCHING;
+ case CaptureResult.CONTROL_AE_STATE_FLASH_REQUIRED:
+ return AeState.FLASH_REQUIRED;
+ case CaptureResult.CONTROL_AE_STATE_CONVERGED:
+ return AeState.CONVERGED;
+ case CaptureResult.CONTROL_AE_STATE_LOCKED:
+ return AeState.LOCKED;
+ default: // fall out
+ }
+ Log.e(TAG, "Undefined ae state: " + state);
+ return AeState.UNKNOWN;
+ }
+
+ /**
+ * Converts the camera2 {@link CaptureResult#CONTROL_AWB_STATE} to {@link AwbState}.
+ *
+ * @return the {@link AwbState}.
+ */
+ @NonNull
+ @Override
+ public AwbState getAwbState() {
+ Integer state = mCaptureResult.get(CaptureResult.CONTROL_AWB_STATE);
+ if (state == null) {
+ return AwbState.UNKNOWN;
+ }
+ switch (state) {
+ case CaptureResult.CONTROL_AWB_STATE_INACTIVE:
+ return AwbState.INACTIVE;
+ case CaptureResult.CONTROL_AWB_STATE_SEARCHING:
+ return AwbState.METERING;
+ case CaptureResult.CONTROL_AWB_STATE_CONVERGED:
+ return AwbState.CONVERGED;
+ case CaptureResult.CONTROL_AWB_STATE_LOCKED:
+ return AwbState.LOCKED;
+ default: // fall out
+ }
+ Log.e(TAG, "Undefined awb state: " + state);
+ return AwbState.UNKNOWN;
+ }
+
+ /**
+ * Converts the camera2 {@link CaptureResult#FLASH_STATE} to {@link FlashState}.
+ *
+ * @return the {@link FlashState}.
+ */
+ @NonNull
+ @Override
+ public FlashState getFlashState() {
+ Integer state = mCaptureResult.get(CaptureResult.FLASH_STATE);
+ if (state == null) {
+ return FlashState.UNKNOWN;
+ }
+ switch (state) {
+ case CaptureResult.FLASH_STATE_UNAVAILABLE:
+ case CaptureResult.FLASH_STATE_CHARGING:
+ return FlashState.NONE;
+ case CaptureResult.FLASH_STATE_READY:
+ return FlashState.READY;
+ case CaptureResult.FLASH_STATE_FIRED:
+ case CaptureResult.FLASH_STATE_PARTIAL:
+ return FlashState.FIRED;
+ default: // fall out
+ }
+ Log.e(TAG, "Undefined flash state: " + state);
+ return FlashState.UNKNOWN;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public long getTimestamp() {
+ Long timestamp = mCaptureResult.get(CaptureResult.SENSOR_TIMESTAMP);
+ if (timestamp == null) {
+ return -1L;
+ }
+
+ return timestamp;
+ }
+
+ @Override
+ public Object getTag() {
+ return mTag;
+ }
+
+
+ public CaptureResult getCaptureResult() {
+ return mCaptureResult;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureCallback.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureCallback.java
new file mode 100644
index 000000000..ee388272e
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureCallback.java
@@ -0,0 +1,24 @@
+package com.quark.quamera.camera.session;
+
+import androidx.annotation.NonNull;
+
+public abstract class CameraCaptureCallback {
+
+ /**
+ * This method is called when an image capture has fully completed and all the result metadata
+ * is available.
+ *
+ * @param cameraCaptureResult The output metadata from the capture.
+ */
+ public void onCaptureCompleted(@NonNull CameraCaptureResult cameraCaptureResult) {
+ }
+
+ /**
+ * This method is called instead of {@link #onCaptureCompleted} when the camera device failed to
+ * produce a {@link CameraCaptureResult} for the request.
+ *
+ * @param failure The output failure from the capture, including the failure reason.
+ */
+ public void onCaptureFailed(@NonNull CameraCaptureFailure failure) {
+ }
+}
\ No newline at end of file
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureCallbackHandlerWrapper.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureCallbackHandlerWrapper.java
new file mode 100644
index 000000000..c3e89777d
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureCallbackHandlerWrapper.java
@@ -0,0 +1,33 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-19
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.os.Handler;
+
+import androidx.annotation.NonNull;
+
+
+public class CameraCaptureCallbackHandlerWrapper extends CameraCaptureCallback {
+ private Handler mHandler;
+ private CameraCaptureCallback mCallback;
+
+ public CameraCaptureCallbackHandlerWrapper(@NonNull Handler handler, @NonNull CameraCaptureCallback callback) {
+ mHandler = handler;
+ mCallback = callback;
+ }
+
+ @Override
+ public void onCaptureCompleted(@NonNull CameraCaptureResult cameraCaptureResult) {
+ mHandler.post(() -> mCallback.onCaptureCompleted(cameraCaptureResult));
+ }
+
+ @Override
+ public void onCaptureFailed(@NonNull CameraCaptureFailure failure) {
+ mHandler.post(() -> mCallback.onCaptureFailed(failure));
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureComboCallback.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureComboCallback.java
new file mode 100644
index 000000000..6dd2d1dd9
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureComboCallback.java
@@ -0,0 +1,39 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/5/26
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import androidx.annotation.NonNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CameraCaptureComboCallback extends CameraCaptureCallback {
+ private final List mCallbackList = new ArrayList<>();
+
+ public void addCallback(CameraCaptureCallback callback) {
+ mCallbackList.add(callback);
+ }
+
+ public void removeCallback(CameraCaptureCallback callback) {
+ mCallbackList.remove(callback);
+ }
+
+ @Override
+ public void onCaptureCompleted(@NonNull CameraCaptureResult cameraCaptureResult) {
+ for (CameraCaptureCallback cameraCaptureCallback : mCallbackList) {
+ cameraCaptureCallback.onCaptureCompleted(cameraCaptureResult);
+ }
+ }
+
+ @Override
+ public void onCaptureFailed(@NonNull CameraCaptureFailure failure) {
+ for (CameraCaptureCallback cameraCaptureCallback : mCallbackList) {
+ cameraCaptureCallback.onCaptureFailed(failure);
+ }
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureFailure.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureFailure.java
new file mode 100644
index 000000000..167ae31de
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureFailure.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camera.session;
+
+import androidx.annotation.RestrictTo;
+import androidx.annotation.RestrictTo.Scope;
+
+/**
+ * A report of failed capture for a single image capture.
+ *
+ * @hide
+ */
+@RestrictTo(Scope.LIBRARY_GROUP)
+public final class CameraCaptureFailure {
+
+ private final Reason mReason;
+
+ /** @hide */
+ @RestrictTo(Scope.LIBRARY_GROUP)
+ public CameraCaptureFailure(Reason reason) {
+ mReason = reason;
+ }
+
+ /**
+ * Determine why the request was dropped, whether due to an error or to a user action.
+ *
+ * @return int The reason code.
+ * @see Reason#ERROR
+ */
+ public Reason getReason() {
+ return mReason;
+ }
+
+ /**
+ * The capture result has been dropped this frame only due to an error in the framework.
+ *
+ * @see #getReason()
+ */
+ public enum Reason {
+ ERROR,
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureMetaData.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureMetaData.java
new file mode 100644
index 000000000..f783e362c
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureMetaData.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camera.session;
+
+import androidx.annotation.RestrictTo;
+import androidx.annotation.RestrictTo.Scope;
+
+/**
+ * This class defines the enumeration constants used for querying the camera capture mode and
+ * results.
+ *
+ * @hide
+ */
+@RestrictTo(Scope.LIBRARY_GROUP)
+public final class CameraCaptureMetaData {
+
+ /** Auto focus (AF) mode. */
+ public enum AfMode {
+
+ /** AF mode is currently unknown. */
+ UNKNOWN,
+
+ /** The AF routine does not control the lens. */
+ OFF,
+
+ /**
+ * AF is triggered on demand.
+ *
+ * In this mode, the lens does not move unless the auto focus trigger action is called.
+ */
+ ON_MANUAL_AUTO,
+
+ /**
+ * AF is continually scanning.
+ *
+ *
In this mode, the AF algorithm modifies the lens position continually to attempt to
+ * provide a constantly-in-focus stream.
+ */
+ ON_CONTINUOUS_AUTO
+ }
+
+ /** Auto focus (AF) state. */
+ public enum AfState {
+
+ /** AF state is currently unknown. */
+ UNKNOWN,
+
+ /** AF is off or not yet has been triggered. */
+ INACTIVE,
+
+ /** AF is performing an AF scan. */
+ SCANNING,
+
+ /** AF currently believes it is in focus. */
+ FOCUSED,
+
+ /** AF believes it is focused correctly and has locked focus. */
+ LOCKED_FOCUSED,
+
+ /** AF has failed to focus and has locked focus. */
+ LOCKED_NOT_FOCUSED
+ }
+
+ /** Auto exposure (AE) state. */
+ public enum AeState {
+
+ /** AE state is currently unknown. */
+ UNKNOWN,
+
+ /** AE is off or has not yet been triggered. */
+ INACTIVE,
+
+ /** AE is performing an AE search. */
+ SEARCHING,
+
+ /**
+ * AE has a good set of control values, but flash needs to be fired for good quality still
+ * capture.
+ */
+ FLASH_REQUIRED,
+
+ /** AE has a good set of control values for the current scene. */
+ CONVERGED,
+
+ /** AE has been locked. */
+ LOCKED
+ }
+
+ /** Auto white balance (AWB) state. */
+ public enum AwbState {
+
+ /** AWB state is currently unknown. */
+ UNKNOWN,
+
+ /** AWB is not in auto mode, or has not yet started metering. */
+ INACTIVE,
+
+ /** AWB is performing AWB metering. */
+ METERING,
+
+ /** AWB has a good set of control values for the current scene. */
+ CONVERGED,
+
+ /** AWB has been locked. */
+ LOCKED
+ }
+
+ /** Flash state. */
+ public enum FlashState {
+
+ /** Flash state is unknown. */
+ UNKNOWN,
+
+ /** Flash is unavailable or not ready to fire. */
+ NONE,
+
+ /** Flash is ready to fire. */
+ READY,
+
+ /** Flash has been fired. */
+ FIRED
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureResult.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureResult.java
new file mode 100644
index 000000000..13407ca0d
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraCaptureResult.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camera.session;
+
+import android.hardware.camera2.CaptureResult;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.RestrictTo.Scope;
+
+
+/**
+ * The result of a single image capture.
+ *
+ * @hide
+ */
+@RestrictTo(Scope.LIBRARY_GROUP)
+public interface CameraCaptureResult {
+
+ /**
+ * Returns the current auto focus mode of operation.
+ */
+ @NonNull
+ CameraCaptureMetaData.AfMode getAfMode();
+
+ /**
+ * Returns the current auto focus state.
+ */
+ @NonNull
+ CameraCaptureMetaData.AfState getAfState();
+
+ /**
+ * Returns the current auto exposure state.
+ */
+ @NonNull
+ CameraCaptureMetaData.AeState getAeState();
+
+ /**
+ * Returns the current auto white balance state.
+ */
+ @NonNull
+ CameraCaptureMetaData.AwbState getAwbState();
+
+ /**
+ * Returns the current flash state.
+ */
+ @NonNull
+ CameraCaptureMetaData.FlashState getFlashState();
+
+ /**
+ * Returns the timestamp in nanoseconds.
+ *
+ *
If the timestamp was unavailable then it will return {@code -1L}.
+ */
+ long getTimestamp();
+
+ /**
+ * Returns the tag associated with the capture request.
+ */
+ Object getTag();
+
+ CaptureResult getCaptureResult();
+
+
+ /**
+ * An implementation of CameraCaptureResult which always return default results.
+ */
+ final class EmptyCameraCaptureResult implements CameraCaptureResult {
+
+ public static CameraCaptureResult create() {
+ return new EmptyCameraCaptureResult();
+ }
+
+ @NonNull
+ @Override
+ public CameraCaptureMetaData.AfMode getAfMode() {
+ return CameraCaptureMetaData.AfMode.UNKNOWN;
+ }
+
+ @NonNull
+ @Override
+ public CameraCaptureMetaData.AfState getAfState() {
+ return CameraCaptureMetaData.AfState.UNKNOWN;
+ }
+
+ @NonNull
+ @Override
+ public CameraCaptureMetaData.AeState getAeState() {
+ return CameraCaptureMetaData.AeState.UNKNOWN;
+ }
+
+ @NonNull
+ @Override
+ public CameraCaptureMetaData.AwbState getAwbState() {
+ return CameraCaptureMetaData.AwbState.UNKNOWN;
+ }
+
+ @NonNull
+ @Override
+ public CameraCaptureMetaData.FlashState getFlashState() {
+ return CameraCaptureMetaData.FlashState.UNKNOWN;
+ }
+
+ @Override
+ public long getTimestamp() {
+ return -1L;
+ }
+
+ @Override
+ public Object getTag() {
+ return null;
+ }
+
+ @Override
+ public CaptureResult getCaptureResult() {
+ return null;
+ }
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraSelector.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraSelector.java
new file mode 100644
index 000000000..8bfe2b596
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CameraSelector.java
@@ -0,0 +1,78 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-18
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import java.util.List;
+
+public class CameraSelector implements ISelector {
+
+ @Override
+ public List filter(List cameraIds) {
+ return null;
+ }
+
+ private CameraLenFacing mFacing;
+
+
+ public enum CameraLenFacing {
+ LEN_FACING_FONT("font"),
+ LEN_FACING_BACK("back");
+
+ private final String mName;
+
+ CameraLenFacing(String name) {
+ this.mName = name;
+ }
+
+ public String getName() {
+ return mName;
+ }
+ }
+
+ public CameraSelector setFacing(CameraLenFacing facing) {
+ mFacing = facing;
+ return this;
+ }
+
+ private boolean mUseWideCamera;
+
+ public CameraSelector useWideCamera(boolean useWideCamera) {
+ mUseWideCamera = useWideCamera;
+ return this;
+ }
+
+ public boolean isUseWideCamera() {
+ return mUseWideCamera;
+ }
+
+ public CameraLenFacing getFacing() {
+ return mFacing;
+ }
+
+ public CameraSelector() {
+ }
+
+
+ public static CameraSelector from(CameraLenFacing facing) {
+ return new CameraSelector().setFacing(facing);
+ }
+
+ public String toLogString() {
+ if (mFacing != null) {
+ return mFacing.getName();
+ }
+ return "unknown";
+ }
+
+
+ public static class Build {
+
+ }
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CaptureCallbackAdapter.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CaptureCallbackAdapter.java
new file mode 100644
index 000000000..da968c1cc
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CaptureCallbackAdapter.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camera.session;
+
+import android.hardware.camera2.CameraCaptureSession;
+import android.hardware.camera2.CaptureFailure;
+import android.hardware.camera2.CaptureRequest;
+import android.hardware.camera2.TotalCaptureResult;
+import android.os.Build;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+/**
+ * An adapter that passes {@link CameraCaptureSession.CaptureCallback} to {@link
+ * CameraCaptureCallback}.
+ */
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+final class CaptureCallbackAdapter extends CameraCaptureSession.CaptureCallback {
+
+ private final CameraCaptureCallback mCameraCaptureCallback;
+
+ CaptureCallbackAdapter(CameraCaptureCallback cameraCaptureCallback) {
+ if (cameraCaptureCallback == null) {
+ throw new NullPointerException("cameraCaptureCallback is null");
+ }
+ mCameraCaptureCallback = cameraCaptureCallback;
+ }
+
+ @Override
+ public void onCaptureSequenceAborted(@NonNull CameraCaptureSession session, int sequenceId) {
+ super.onCaptureSequenceAborted(session, sequenceId);
+ }
+
+ @Override
+ public void onCaptureCompleted(
+ @NonNull CameraCaptureSession session,
+ @NonNull CaptureRequest request,
+ @NonNull TotalCaptureResult result) {
+ super.onCaptureCompleted(session, request, result);
+
+ mCameraCaptureCallback.onCaptureCompleted(
+ new Camera2CameraCaptureResult(request.getTag(), result));
+ }
+
+ @Override
+ public void onCaptureFailed(
+ @NonNull CameraCaptureSession session,
+ @NonNull CaptureRequest request,
+ @NonNull CaptureFailure failure) {
+ super.onCaptureFailed(session, request, failure);
+
+ CameraCaptureFailure cameraFailure =
+ new CameraCaptureFailure(CameraCaptureFailure.Reason.ERROR);
+
+ mCameraCaptureCallback.onCaptureFailed(cameraFailure);
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CaptureCallbackHandlerWrapper.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CaptureCallbackHandlerWrapper.java
new file mode 100644
index 000000000..31e4ea808
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CaptureCallbackHandlerWrapper.java
@@ -0,0 +1,72 @@
+package com.quark.quamera.camera.session;
+
+import android.hardware.camera2.CameraCaptureSession;
+import android.hardware.camera2.CaptureFailure;
+import android.hardware.camera2.CaptureRequest;
+import android.hardware.camera2.CaptureResult;
+import android.hardware.camera2.TotalCaptureResult;
+import android.os.Build;
+import android.view.Surface;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import java.util.concurrent.Executor;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+final class CaptureCallbackHandlerWrapper extends CameraCaptureSession.CaptureCallback {
+
+ final CameraCaptureSession.CaptureCallback mWrappedCallback;
+ private final Executor mExecutor;
+
+ CaptureCallbackHandlerWrapper(@NonNull Executor executor,
+ @NonNull CameraCaptureSession.CaptureCallback wrappedCallback) {
+ mExecutor = executor;
+ mWrappedCallback = wrappedCallback;
+ }
+
+ @Override
+ public void onCaptureStarted(@NonNull final CameraCaptureSession session,
+ @NonNull final CaptureRequest request, final long timestamp,
+ final long frameNumber) {
+ mExecutor.execute(() -> mWrappedCallback.onCaptureStarted(session, request, timestamp, frameNumber));
+ }
+
+ @Override
+ public void onCaptureProgressed(@NonNull final CameraCaptureSession session,
+ @NonNull final CaptureRequest request, @NonNull final CaptureResult partialResult) {
+ mExecutor.execute(() -> mWrappedCallback.onCaptureProgressed(session, request, partialResult));
+ }
+
+ @Override
+ public void onCaptureCompleted(@NonNull final CameraCaptureSession session,
+ @NonNull final CaptureRequest request, @NonNull final TotalCaptureResult result) {
+ mExecutor.execute(() -> mWrappedCallback.onCaptureCompleted(session, request, result));
+ }
+
+ @Override
+ public void onCaptureFailed(@NonNull final CameraCaptureSession session,
+ @NonNull final CaptureRequest request, @NonNull final CaptureFailure failure) {
+ mExecutor.execute(() -> mWrappedCallback.onCaptureFailed(session, request, failure));
+ }
+
+ @Override
+ public void onCaptureSequenceCompleted(@NonNull final CameraCaptureSession session,
+ final int sequenceId, final long frameNumber) {
+ mExecutor.execute(() -> mWrappedCallback.onCaptureSequenceCompleted(session, sequenceId, frameNumber));
+ }
+
+ @Override
+ public void onCaptureSequenceAborted(@NonNull final CameraCaptureSession session,
+ final int sequenceId) {
+ mExecutor.execute(() -> mWrappedCallback.onCaptureSequenceAborted(session, sequenceId));
+ }
+
+ @RequiresApi(24)
+ @Override
+ public void onCaptureBufferLost(@NonNull final CameraCaptureSession session,
+ @NonNull final CaptureRequest request, @NonNull final Surface target,
+ final long frameNumber) {
+ mExecutor.execute(() -> mWrappedCallback.onCaptureBufferLost(session, request, target, frameNumber));
+ }
+}
\ No newline at end of file
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CaptureControlCallback.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CaptureControlCallback.java
new file mode 100644
index 000000000..ab2cfbb96
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/CaptureControlCallback.java
@@ -0,0 +1,71 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-18
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.hardware.camera2.CameraCaptureSession;
+import android.hardware.camera2.CaptureFailure;
+import android.hardware.camera2.CaptureRequest;
+import android.hardware.camera2.CaptureResult;
+import android.hardware.camera2.TotalCaptureResult;
+import android.os.Build;
+import android.view.Surface;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import com.quark.quamera.camera.camera.Camera2CameraImpl;
+import com.quark.quamera.util.CameraLogger;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class CaptureControlCallback extends CameraCaptureSession.CaptureCallback {
+
+ private long sLastLogTime = -1;
+ private boolean mNeedLog = false;
+
+ @Override
+ public void onCaptureStarted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, long timestamp, long frameNumber) {
+ super.onCaptureStarted(session, request, timestamp, frameNumber);
+
+ }
+
+ @Override
+ public void onCaptureProgressed(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull CaptureResult partialResult) {
+ super.onCaptureProgressed(session, request, partialResult);
+ }
+
+ @Override
+ public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
+ super.onCaptureCompleted(session, request, result);
+ if (System.currentTimeMillis() - sLastLogTime > 2000) {
+ sLastLogTime = System.currentTimeMillis();
+ CameraLogger.i(Camera2CameraImpl.TAG, "onCaptureCompleted " + request.getTag());
+ }
+ }
+
+ @Override
+ public void onCaptureFailed(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull CaptureFailure failure) {
+ super.onCaptureFailed(session, request, failure);
+ CameraLogger.i(Camera2CameraImpl.TAG, "onCaptureFailed " + request.getTag());
+ }
+
+ @Override
+ public void onCaptureSequenceCompleted(@NonNull CameraCaptureSession session, int sequenceId, long frameNumber) {
+ super.onCaptureSequenceCompleted(session, sequenceId, frameNumber);
+ }
+
+ @Override
+ public void onCaptureSequenceAborted(@NonNull CameraCaptureSession session, int sequenceId) {
+ super.onCaptureSequenceAborted(session, sequenceId);
+ CameraLogger.i(Camera2CameraImpl.TAG, "onCaptureSequenceAborted " + sequenceId);
+ }
+
+ @Override
+ public void onCaptureBufferLost(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull Surface target, long frameNumber) {
+ super.onCaptureBufferLost(session, request, target, frameNumber);
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/ComboSessionCaptureCallback.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/ComboSessionCaptureCallback.java
new file mode 100644
index 000000000..f74da3f2b
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/ComboSessionCaptureCallback.java
@@ -0,0 +1,92 @@
+package com.quark.quamera.camera.session;
+
+import android.hardware.camera2.CameraCaptureSession;
+import android.hardware.camera2.CaptureFailure;
+import android.hardware.camera2.CaptureRequest;
+import android.hardware.camera2.CaptureResult;
+import android.hardware.camera2.TotalCaptureResult;
+import android.os.Build;
+import android.view.Surface;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+final class ComboSessionCaptureCallback
+ extends CameraCaptureSession.CaptureCallback {
+ private final List mCallbacks = new ArrayList<>();
+
+ ComboSessionCaptureCallback(List callbacks) {
+ for (CameraCaptureSession.CaptureCallback callback : callbacks) {
+ if (callback == null) {
+ continue;
+ }
+ mCallbacks.add(callback);
+ }
+ }
+
+ @RequiresApi(api = Build.VERSION_CODES.N)
+ @Override
+ public void onCaptureBufferLost(
+ @NonNull CameraCaptureSession session, @NonNull CaptureRequest request,
+ @NonNull Surface surface, long frame) {
+ for (CameraCaptureSession.CaptureCallback callback : mCallbacks) {
+ callback.onCaptureBufferLost(session, request, surface, frame);
+ }
+ }
+
+ @Override
+ public void onCaptureCompleted(
+ @NonNull CameraCaptureSession session, @NonNull CaptureRequest request,
+ @NonNull TotalCaptureResult result) {
+ for (CameraCaptureSession.CaptureCallback callback : mCallbacks) {
+ callback.onCaptureCompleted(session, request, result);
+ }
+ }
+
+ @Override
+ public void onCaptureFailed(
+ @NonNull CameraCaptureSession session, @NonNull CaptureRequest request,
+ @NonNull CaptureFailure failure) {
+ for (CameraCaptureSession.CaptureCallback callback : mCallbacks) {
+ callback.onCaptureFailed(session, request, failure);
+ }
+ }
+
+ @Override
+ public void onCaptureProgressed(
+ @NonNull CameraCaptureSession session, @NonNull CaptureRequest request,
+ @NonNull CaptureResult partialResult) {
+ for (CameraCaptureSession.CaptureCallback callback : mCallbacks) {
+ callback.onCaptureProgressed(session, request, partialResult);
+ }
+ }
+
+ @Override
+ public void onCaptureSequenceAborted(@NonNull CameraCaptureSession session,
+ int sequenceId) {
+ for (CameraCaptureSession.CaptureCallback callback : mCallbacks) {
+ callback.onCaptureSequenceAborted(session, sequenceId);
+ }
+ }
+
+ @Override
+ public void onCaptureSequenceCompleted(
+ @NonNull CameraCaptureSession session, int sequenceId, long frame) {
+ for (CameraCaptureSession.CaptureCallback callback : mCallbacks) {
+ callback.onCaptureSequenceCompleted(session, sequenceId, frame);
+ }
+ }
+
+ @Override
+ public void onCaptureStarted(
+ @NonNull CameraCaptureSession session, @NonNull CaptureRequest request,
+ long timestamp, long frame) {
+ for (CameraCaptureSession.CaptureCallback callback : mCallbacks) {
+ callback.onCaptureStarted(session, request, timestamp, frame);
+ }
+ }
+}
\ No newline at end of file
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/ISelector.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/ISelector.java
new file mode 100644
index 000000000..bcff1c2ae
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/ISelector.java
@@ -0,0 +1,14 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-18
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import java.util.List;
+
+public interface ISelector {
+ public List filter(List cameraIds);
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/ISurfaceUpdateListener.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/ISurfaceUpdateListener.java
new file mode 100644
index 000000000..a302e427b
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/ISurfaceUpdateListener.java
@@ -0,0 +1,32 @@
+package com.quark.quamera.camera.session;
+
+import com.quark.quamera.camera.preview.SurfaceTextureWrapper;
+
+public abstract class ISurfaceUpdateListener extends CameraCaptureCallback {
+
+
+ private SurfaceTextureWrapper mSurfaceTextureWrapper;
+
+ public SurfaceTextureWrapper getSurfaceTextureWrapper() {
+ return mSurfaceTextureWrapper;
+ }
+
+ public void onCreate(SurfaceTextureWrapper surfaceTextureWrapper) {
+ mSurfaceTextureWrapper = surfaceTextureWrapper;
+ onCreate();
+ }
+
+// @Override
+// public void onCaptureCompleted(@NonNull CameraCaptureResult cameraCaptureResult) {
+// }
+//
+// @Override
+// public void onCaptureFailed(@NonNull CameraCaptureFailure failure) {
+// }
+
+
+ protected abstract void onRelease();
+
+ protected abstract void onCreate();
+
+}
\ No newline at end of file
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/IUserCameraSession.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/IUserCameraSession.java
new file mode 100644
index 000000000..7b3028d1c
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/IUserCameraSession.java
@@ -0,0 +1,24 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-18
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+public interface IUserCameraSession {
+
+ enum State {
+ ACTIVE,
+ INACTIVE
+ }
+
+
+ boolean active();
+
+ boolean inactive();
+
+ boolean isActive();
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/ImageCapture.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/ImageCapture.java
new file mode 100644
index 000000000..5fd749e85
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/ImageCapture.java
@@ -0,0 +1,371 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/4/19
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.graphics.Matrix;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraMetadata;
+import android.hardware.camera2.CaptureRequest;
+import android.media.Image;
+import android.os.Build;
+import android.util.LayoutDirection;
+import android.util.Size;
+
+import com.quark.quamera.camera.camera.Camera2CameraImpl;
+import com.quark.quamera.camera.camera.Camera2Info;
+import com.quark.quamera.camera.imagereader.DeferrableImageReader;
+import com.quark.quamera.camera.preview.IPreviewView;
+import com.quark.quamera.camera.preview.ViewPorts;
+import com.quark.quamera.camera.session.config.CameraConfigUtils;
+import com.quark.quamera.util.CameraLogger;
+import com.quark.quamera.util.ImageUtils;
+import com.quark.quamera.util.Should;
+
+import java.io.ByteArrayInputStream;
+import java.nio.ByteBuffer;
+import java.util.LinkedList;
+import java.util.Locale;
+import java.util.Queue;
+
+import androidx.annotation.IntRange;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.exifinterface.media.ExifInterface;
+
+import static com.quark.quamera.util.ImageUtils.min;
+import static com.quark.quamera.util.ImageUtils.sizeToVertexes;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class ImageCapture {
+
+ private DeferrableImageReader mDeferrableImageReader;
+
+ private Camera2CameraImpl mCamera;
+
+ private IPreviewView mPreviewView;
+
+ public static final class CameraCaptureLogBean {
+ public boolean isCameraFocused = false;
+ public boolean isCameraZoomed = false;
+ }
+
+ /**
+ * Callback for when an image capture has completed.
+ */
+ public abstract static class OnImageCapturedCallback {
+
+ private RectF mCameraShowRectAccordingToPreviewView;
+ // 相机是否聚焦过，用于埋点上报
+ private CameraCaptureLogBean mCameraLogBean;
+
+ public RectF getCameraShowRectAccordingToPreviewView() {
+ return mCameraShowRectAccordingToPreviewView;
+ }
+
+ public void setCameraShowRectAccordingToPreviewView(RectF cameraShowRectAccordingToPreviewView) {
+ mCameraShowRectAccordingToPreviewView = cameraShowRectAccordingToPreviewView;
+ }
+
+ public CameraCaptureLogBean getCameraLogBean() {
+ return mCameraLogBean;
+ }
+
+ public void setCameraLogBean(CameraCaptureLogBean cameraLogBean) {
+ this.mCameraLogBean = cameraLogBean;
+ }
+
+ public abstract void onCaptureSuccess(@NonNull byte[] jpeg, Size size, Rect previewCropRect, int rotation);
+
+ public void onError(@NonNull final Exception exception) {
+ }
+
+
+ }
+
+ public void bindPreviewView(IPreviewView previewView) {
+ mPreviewView = previewView;
+ }
+
+ public void bindCamera(Camera2CameraImpl control) {
+ mCamera = control;
+ }
+
+
+ private Size mCaptureSurfaceSize;
+
+ public void updateCaptureSurfaceSize(Size size) {
+ mCaptureSurfaceSize = size;
+ }
+
+
+ /**
+ * 预览画面相对于拍照内容的区域
+ */
+ public Rect getViewPointRect() {
+ if (mPreviewView == null || mCamera == null || mCaptureSurfaceSize == null) {
+ return null;
+ }
+
+ Camera2Info camera2Info = mCamera.getCamera2Info();
+
+ return ViewPorts.calculateViewPortRect(
+ camera2Info.getSensorRect(),
+ camera2Info.isFrontCamera(),
+ mPreviewView.getAspectRatio(),
+ getRelativeRotation(mPreviewView.getViewRotation()),
+ mPreviewView.getScaleType(),
+ LayoutDirection.LTR,
+ mCaptureSurfaceSize
+ );
+ }
+
+ public RectF getPreviewShowRectAccordingToView() {
+ if (mPreviewView == null || mCamera == null) {
+ return null;
+ }
+ return mPreviewView.getCameraShowRect();
+ }
+
+ @IntRange(from = 0, to = 359)
+ private int getRelativeRotation(int previewRotation) {
+ if (previewRotation != 0) {
+ Should.fail("not support now");
+ }
+ if (mCamera != null) {
+ return mCamera.getCamera2Info().getSensorOrientation();
+ }
+ return 0;
+ }
+
+
+ private static class CaptureTask {
+ private final int mRelativeDegrees;
+ private final @NonNull
+ SingleCaptureConfig mConfig;
+ private final Rect mViewPortRect;
+ private final @NonNull
+ ImageCapture.OnImageCapturedCallback mCallback;
+
+ public CaptureTask(@Nullable Rect viewPortCropRect,
+ int relativeRotation,
+ @NonNull SingleCaptureConfig config,
+ @NonNull OnImageCapturedCallback callback,
+ @Nullable RectF cameraPreviewShowRectAccordingToView) {
+ this.mConfig = config;
+ this.mViewPortRect = viewPortCropRect;
+ this.mRelativeDegrees = relativeRotation;
+ this.mCallback = callback;
+ mCallback.setCameraShowRectAccordingToPreviewView(cameraPreviewShowRectAccordingToView);
+ }
+
+ public @NonNull
+ SingleCaptureConfig getConfig() {
+ return mConfig;
+ }
+
+ public void dispatchImage(Image image) {
+ int dispatchRotationDegrees = 0;
+
+ try {
+ Size size = new Size(image.getWidth(), image.getHeight());
+ Image.Plane[] planes = image.getPlanes();
+ ByteBuffer buffer = planes[0].getBuffer();
+ byte[] data = new byte[buffer.capacity()];
+ buffer.get(data);
+
+ Size dispatchResolution;
+ if (ImageUtils.shouldUseExifOrientation(image)) {
+ try {
+
+ ExifInterface exif;
+
+
+ exif = new ExifInterface(new ByteArrayInputStream(data));
+ buffer.rewind();
+
+ int exifRotation = exif.getAttributeInt(
+ ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_UNDEFINED);
+
+ dispatchRotationDegrees = ImageUtils.getRotation(exifRotation);
+ int jpegWidth = exif.getAttributeInt(ExifInterface.TAG_IMAGE_WIDTH, 0);
+ int jpegHeight = exif.getAttributeInt(ExifInterface.TAG_IMAGE_LENGTH, 0);
+
+ dispatchResolution = new Size(jpegWidth, jpegHeight);
+ } catch (Exception e) {
+ notifyError(e);
+ return;
+ }
+ } else {
+ dispatchResolution = new Size(image.getWidth(), image.getHeight());
+ }
+ Rect imageCropRect = getDispatchCropRect(mViewPortRect, mRelativeDegrees, dispatchResolution, dispatchRotationDegrees);
+ notifySuccess(data, size, imageCropRect, dispatchRotationDegrees);
+
+ } catch (Exception e) {
+ notifyError(e);
+ } finally {
+ image.close();
+ }
+
+ }
+
+
+ public void notifySuccess(@NonNull byte[] jpeg, Size size, Rect previewCropRect, int rotation) {
+ mCallback.onCaptureSuccess(jpeg, size, previewCropRect, rotation);
+ }
+
+ public void notifyError(Exception throwable) {
+ mCallback.onError(throwable);
+ }
+
+
+ }
+
+
+ private final Queue mPendingTasks = new LinkedList<>();
+ private CaptureTask mRunningTask;
+
+ private void addTask(@NonNull CaptureTask task) {
+ mPendingTasks.add(task);
+ }
+
+ private void triggerNext() {
+ if (mRunningTask != null) {
+ return;
+ }
+ mRunningTask = mPendingTasks.poll();
+
+ if (mRunningTask == null) {
+ return;
+ }
+ if (mCamera == null) {
+ mRunningTask.notifyError(new IllegalStateException("not camera bind"));
+ triggerNext();
+ }
+
+ mCamera.capture(mRunningTask.getConfig(), new InnerImageCaptureCallback() {
+ @Override
+ public void onCaptureStart() {
+ if (mPreviewView != null) {
+ mPreviewView.doTakePhotoAnimation();
+ }
+ }
+
+ @Override
+ public void onCaptureSuccess(Image image) {
+ mRunningTask.dispatchImage(image);
+ mRunningTask = null;
+ triggerNext();
+ }
+
+ @Override
+ public void onError(Exception e) {
+ mRunningTask.notifyError(e);
+ mRunningTask = null;
+ triggerNext();
+ }
+ });
+ }
+
+
+ public void takePicture(@NonNull SingleCaptureConfig singleCaptureConfig,
+ @NonNull ImageCapture.OnImageCapturedCallback capturedCallback) {
+
+
+ Rect viewPortCropRect = getViewPointRect();
+ RectF previewShowRectAccordingToView = getPreviewShowRectAccordingToView();
+ CameraLogger.i("ImageCapture", "update capture view port crop rect %s", viewPortCropRect);
+ addTask(new CaptureTask(
+ viewPortCropRect,
+ mPreviewView != null ? getRelativeRotation(mPreviewView.getViewRotation()) : 0,
+ singleCaptureConfig,
+ capturedCallback,
+ previewShowRectAccordingToView));
+
+ triggerNext();
+ }
+
+
+ public void setDeferrableImageReader(DeferrableImageReader deferrableImageReader) {
+ mDeferrableImageReader = deferrableImageReader;
+ }
+
+
+ public DeferrableImageReader getDeferrableImageReader() {
+ return mDeferrableImageReader;
+ }
+
+
+ void fillConfig(@NonNull CameraCharacteristics cameraCharacteristics, @NonNull CaptureRequest.Builder builder) {
+ // Use the same AE and AF modes as the preview.
+ //AF:自动对焦
+ CameraConfigUtils.checkAndSetConfigIntValue(cameraCharacteristics, builder,
+ CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES, CaptureRequest.CONTROL_AF_MODE, CameraMetadata.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
+
+ //AE:自动曝光
+ CameraConfigUtils.checkAndSetConfigIntValue(cameraCharacteristics, builder,
+ CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES, CaptureRequest.CONTROL_AE_MODE, CameraMetadata.CONTROL_AE_MODE_ON);
+
+ }
+
+ /**
+ * Corrects crop rect based on JPEG exif rotation.
+ *
+ * The original crop rect is calculated based on camera sensor buffer. On some devices,
+ * the buffer is rotated before being passed to users, in which case the crop rect also
+ * needs additional transformations.
+ *
+ *
There are two most common scenarios: 1) exif rotation is 0, or 2) exif rotation
+ * equals output rotation. 1) means the HAL rotated the buffer based on target
+ * rotation. 2) means HAL no-oped on the rotation. Theoretically only 1) needs
+ * additional transformations, but this method is also generic enough to handle all possible
+ * HAL rotations.
+ */
+ @NonNull
+ static Rect getDispatchCropRect(@NonNull Rect surfaceCropRect, int surfaceToOutputDegrees,
+ @NonNull Size dispatchResolution, int dispatchToOutputDegrees) {
+
+
+ CameraLogger.i("ViewPorts", String.format(Locale.CHINA, "getDispatchCropRect surfaceCropRect:%s " +
+ "surfaceToOutputDegrees:%d dispatchResolution:%s dispatchToOutputDegrees:%d", surfaceCropRect,
+ surfaceToOutputDegrees, dispatchResolution, dispatchToOutputDegrees));
+
+
+ // There are 3 coordinate systems: surface, dispatch and output. Surface is where
+ // the original crop rect is defined. We need to figure out what HAL
+ // has done to the buffer (the surface->dispatch mapping) and apply the same
+ // transformation to the crop rect.
+ // The surface->dispatch mapping is calculated by inverting a dispatch->surface mapping.
+
+ Matrix matrix = new Matrix();
+ // Apply the dispatch->surface rotation.
+ matrix.setRotate(dispatchToOutputDegrees - surfaceToOutputDegrees);
+ // Apply the dispatch->surface translation. The translation is calculated by
+ // compensating for the offset caused by the dispatch->surface rotation.
+ float[] vertexes = sizeToVertexes(dispatchResolution);
+ matrix.mapPoints(vertexes);
+ float left = min(vertexes[0], vertexes[2], vertexes[4], vertexes[6]);
+ float top = min(vertexes[1], vertexes[3], vertexes[5], vertexes[7]);
+ matrix.postTranslate(-left, -top);
+ // Inverting the dispatch->surface mapping to get the surface->dispatch mapping.
+ matrix.invert(matrix);
+
+ // Apply the surface->dispatch mapping to surface crop rect.
+ RectF dispatchCropRectF = new RectF();
+ matrix.mapRect(dispatchCropRectF, new RectF(surfaceCropRect));
+ dispatchCropRectF.sort();
+ Rect dispatchCropRect = new Rect();
+ dispatchCropRectF.round(dispatchCropRect);
+ return dispatchCropRect;
+ }
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/InnerImageCaptureCallback.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/InnerImageCaptureCallback.java
new file mode 100644
index 000000000..a996c0fdb
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/InnerImageCaptureCallback.java
@@ -0,0 +1,21 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/7/13
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.media.Image;
+
+public interface InnerImageCaptureCallback {
+
+
+ void onCaptureStart();
+
+ void onCaptureSuccess(Image image);
+
+ void onError(Exception e);
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/PreviewConfig.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/PreviewConfig.java
new file mode 100644
index 000000000..8d8d91708
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/PreviewConfig.java
@@ -0,0 +1,204 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-24
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraMetadata;
+import android.hardware.camera2.CaptureRequest;
+import android.os.Build;
+import android.util.Range;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import com.quark.quamera.camera.camera.Camera2Info;
+import com.quark.quamera.camera.camera.CameraSurfaceHelper;
+import com.quark.quamera.camera.imagereader.DeferrableImageReader;
+import com.quark.quamera.camera.preview.IPreviewView;
+import com.quark.quamera.camera.session.config.CameraConfigUtils;
+
+import java.util.List;
+import java.util.concurrent.Executor;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class PreviewConfig {
+
+ private final int mExceptWidth;
+ private final int mExceptHeight;
+
+ private int mActualWidth;
+ private int mActualHeight;
+
+ private RepeatCaptureRequestConfig mPreviewCaptureConfig;
+
+
+ private CameraSurfaceHelper.ISuggestionCalculation mSuggestionCalculation;
+
+ private @NonNull
+ IPreviewView mPreviewView;
+
+ private List mImageReaders;
+
+ private final CameraCaptureComboCallback mRepeatCaptureCallback = new CameraCaptureComboCallback();
+
+
+ public CameraCaptureComboCallback getRepeatCaptureCallback() {
+ return mRepeatCaptureCallback;
+ }
+
+ public PreviewConfig setImageReaders(List imageReaders) {
+ mImageReaders = imageReaders;
+ return this;
+ }
+
+
+ public PreviewConfig setSizeCalculation(CameraSurfaceHelper.ISuggestionCalculation sizeCalculation) {
+ mSuggestionCalculation = sizeCalculation;
+ return this;
+ }
+
+ public CameraSurfaceHelper.ISuggestionCalculation getSuggestionCalculation() {
+ return mSuggestionCalculation;
+ }
+
+ public List getImageReaders() {
+ return mImageReaders;
+ }
+
+ /**
+ * 相机传感器的宽高,默认情况下，相机传感器长边为宽
+ * 最终给出的Surface的宽高不一定等于预期的，会从硬件支持中，找到最相近的尺寸
+ *
+ * @param exceptWidth 相机传感器预期宽度（长边）
+ * @param exceptHeight 相机传感器预期高度（短边）
+ */
+ public PreviewConfig(int exceptWidth, int exceptHeight, @NonNull IPreviewView previewView) {
+ mExceptWidth = exceptWidth;
+ mExceptHeight = exceptHeight;
+ mPreviewView = previewView;
+ }
+
+ public IPreviewView getPreviewView() {
+ return mPreviewView;
+ }
+
+
+ public int getExpectWidth() {
+ return mExceptWidth;
+ }
+
+ public int getExpectHeight() {
+ return mExceptHeight;
+ }
+
+ public int getActualWidth() {
+ return mActualWidth;
+ }
+
+ public void setActualWidth(int actualWidth) {
+ mActualWidth = actualWidth;
+ }
+
+ public int getActualHeight() {
+ return mActualHeight;
+ }
+
+ public void setActualHeight(int actualHeight) {
+ mActualHeight = actualHeight;
+ }
+
+
+ public @NonNull
+ synchronized RepeatCaptureRequestConfig getRepeatCaptureRequestConfig() {
+ if (mPreviewCaptureConfig == null) {
+ mPreviewCaptureConfig = new RepeatCaptureRequestConfig() {
+
+ @Override
+ public void fillConfig(@NonNull Camera2Info cameraInfo, @NonNull CaptureRequest.Builder builder) {
+ CameraCharacteristics cameraCharacteristics = cameraInfo.getCameraCharacteristics();
+// //预览的默认配置
+//
+ Range ae_compensation_range =
+ cameraCharacteristics.get(CameraCharacteristics.CONTROL_AE_COMPENSATION_RANGE);
+
+ int expectAECompensation = 0;
+ if (ae_compensation_range.contains(expectAECompensation)) {
+ builder.set(CaptureRequest.CONTROL_AE_EXPOSURE_COMPENSATION, expectAECompensation);
+ builder.set(CaptureRequest.CONTROL_AE_EXPOSURE_COMPENSATION, expectAECompensation);
+ }
+
+
+ //AF:自动对焦
+
+ CameraConfigUtils.checkAndSetConfigIntValue(cameraCharacteristics, builder,
+ CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES, CaptureRequest.CONTROL_AE_MODE, CameraMetadata.CONTROL_AE_MODE_ON);
+
+
+ //AF:自动对焦
+
+ CameraConfigUtils.checkAndSetConfigIntValue(cameraCharacteristics, builder,
+ CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES, CaptureRequest.CONTROL_AF_MODE, CameraMetadata.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
+
+
+ //AWB:自动白平衡
+
+
+ CameraConfigUtils.checkAndSetConfigIntValue(cameraCharacteristics, builder,
+ CameraCharacteristics.CONTROL_AWB_AVAILABLE_MODES, CaptureRequest.CONTROL_AWB_MODE, CameraMetadata.CONTROL_AWB_MODE_AUTO);
+
+
+ if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
+ CameraConfigUtils.checkAndSetConfigIntValue(cameraCharacteristics, builder,
+ CameraCharacteristics.CONTROL_AVAILABLE_MODES, CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
+ }
+
+// if (cameraInfo.getCameraLenFacing() == CameraSelector.CameraLenFacing.LEN_FACING_BACK) {
+// //临时做法，临时在代码设计，后续将前后相机的配置分开实现
+// //前置相机的AE时间要长一点，不然画面会偏暗
+// Range[] fpsRanges = cameraCharacteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
+//
+// Range bestRange = null;
+// Range secondRange = null;
+// for (Range range : fpsRanges) {
+// if (range.getLower() == 30 && range.getUpper() == 30) {
+// bestRange = range;
+// break;
+// }
+// if (range.getLower() >= 25 && range.getUpper() <= 35) {
+// secondRange = range;
+// }
+// }
+// if (bestRange == null) {
+// bestRange = secondRange;
+// }
+//
+// if (bestRange != null) {
+// builder.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, bestRange);
+// }
+// }
+
+ builder.setTag("Preview&ImageReader");
+
+ }
+
+ @Override
+ public synchronized CameraCaptureCallback getCallback() {
+ return mRepeatCaptureCallback;
+ }
+
+ @Override
+ public synchronized Executor getCallbackExecutor() {
+ return null;
+ }
+ }
+
+ ;
+ }
+ return mPreviewCaptureConfig;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/RepeatCaptureRequestConfig.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/RepeatCaptureRequestConfig.java
new file mode 100644
index 000000000..06b9442a3
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/RepeatCaptureRequestConfig.java
@@ -0,0 +1,33 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-19
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.hardware.Camera;
+import android.hardware.camera2.CaptureRequest;
+
+import androidx.annotation.NonNull;
+
+import com.quark.quamera.camera.camera.Camera2Info;
+
+import java.util.concurrent.Executor;
+
+//TODO 后面要解决fill里面的属性都不支持的时候，就不需要重新发起repeatSession
+public interface RepeatCaptureRequestConfig {
+
+
+ void fillConfig(@NonNull Camera2Info cameraInfo,
+ @NonNull CaptureRequest.Builder builder);
+
+ CameraCaptureCallback getCallback();
+
+ default Executor getCallbackExecutor() {
+ return null;
+ }
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/SessionConfig.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/SessionConfig.java
new file mode 100644
index 000000000..b167a3337
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/SessionConfig.java
@@ -0,0 +1,68 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-18
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.os.Handler;
+import android.os.Looper;
+
+import androidx.annotation.NonNull;
+
+import com.quark.quamera.camera.camera.CameraErrorListenerHandlerWrapper;
+import com.quark.quamera.camera.camera.ICameraErrorListener;
+import com.quark.quamera.camera.session.config.CameraSelectConfig;
+
+
+public class SessionConfig {
+
+
+ private final PreviewConfig mPreviewConfig;
+
+ private ImageCapture mCaptureConfig;
+
+ private ICameraErrorListener mCameraErrorListener;
+
+ private CameraSelectConfig mSelectConfig;
+
+
+ public SessionConfig(@NonNull PreviewConfig previewConfig) {
+ mPreviewConfig = previewConfig;
+ }
+
+ public void setCaptureConfig(ImageCapture captureConfig) {
+ mCaptureConfig = captureConfig;
+ }
+
+ public void setSelectConfig(CameraSelectConfig selectConfig) {
+ mSelectConfig = selectConfig;
+ }
+
+ public @NonNull
+ PreviewConfig getPreviewConfig() {
+ return mPreviewConfig;
+ }
+
+ public ImageCapture getImageCapture() {
+ return mCaptureConfig;
+ }
+
+ public CameraSelectConfig getSelectConfig() {
+ return mSelectConfig;
+ }
+
+ public void setCameraErrorListener(@NonNull ICameraErrorListener cameraErrorListener, Handler handler) {
+ if (handler == null) {
+ mCameraErrorListener = cameraErrorListener;
+ } else {
+ mCameraErrorListener = new CameraErrorListenerHandlerWrapper(new Handler(Looper.getMainLooper()), cameraErrorListener);
+ }
+ }
+
+ public ICameraErrorListener getCameraErrorListener() {
+ return mCameraErrorListener;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/SingleCaptureConfig.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/SingleCaptureConfig.java
new file mode 100644
index 000000000..9e0256581
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/SingleCaptureConfig.java
@@ -0,0 +1,60 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/6/18
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.graphics.RectF;
+import android.view.View;
+
+import androidx.annotation.IntRange;
+
+public class SingleCaptureConfig {
+
+ private boolean mDetectDeviceRotation;
+
+ private byte mJpegQuality = 100;
+
+ public boolean useNatureRotation() {
+ return mDetectDeviceRotation;
+ }
+
+ private RectF mCameraShowRect ;
+
+ public RectF getCameraShowRect() {
+ return mCameraShowRect;
+ }
+
+ public void setCameraShowRect(RectF cameraShowRect) {
+ mCameraShowRect = cameraShowRect;
+ }
+
+ /**
+ * 是否根据手机姿态照片旋转到正确的角度(部分手机旋转信息放在拍照出来的jpeg的exif信息中)
+ */
+ public SingleCaptureConfig setDetectDeviceRotation(boolean detectDeviceRotation) {
+ mDetectDeviceRotation = detectDeviceRotation;
+ return this;
+ }
+
+ public byte getJpegQuality() {
+ return mJpegQuality;
+ }
+
+ /**
+ * Compression quality of the final JPEG
+ * image.
+ * 85-95 is typical usage range. This tag is also used to describe the quality
+ * of the HEIC image capture.
+ * Range of valid values:
+ * 1-100; larger is higher quality
+ * This key is available on all devices.
+ */
+ public SingleCaptureConfig setJpegQuality(@IntRange(from = 0, to = 100) int jpegQuality) {
+ mJpegQuality = (byte) jpegQuality;
+ return this;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/SurfaceUpdateListenerExecutorWrapper.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/SurfaceUpdateListenerExecutorWrapper.java
new file mode 100644
index 000000000..173e2db3d
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/SurfaceUpdateListenerExecutorWrapper.java
@@ -0,0 +1,34 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-12-18
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import androidx.annotation.NonNull;
+
+import java.util.concurrent.Executor;
+
+public class SurfaceUpdateListenerExecutorWrapper extends ISurfaceUpdateListener {
+
+ private Executor mExecutor;
+ private ISurfaceUpdateListener mListener;
+
+
+ public SurfaceUpdateListenerExecutorWrapper(@NonNull Executor executor, @NonNull ISurfaceUpdateListener listener) {
+ mExecutor = executor;
+ mListener = listener;
+ }
+
+ @Override
+ public void onRelease() {
+ mExecutor.execute(() -> mListener.onRelease());
+ }
+
+ @Override
+ public void onCreate() {
+ mExecutor.execute(() -> mListener.onCreate());
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/SyncCaptureSession.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/SyncCaptureSession.java
new file mode 100644
index 000000000..8270ca831
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/SyncCaptureSession.java
@@ -0,0 +1,513 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-23
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCaptureSession;
+import android.hardware.camera2.CameraDevice;
+import android.hardware.camera2.CaptureFailure;
+import android.hardware.camera2.CaptureRequest;
+import android.media.ImageReader;
+import android.os.Build;
+import android.os.Handler;
+import android.util.Log;
+import android.view.Surface;
+
+import com.quark.quamera.camera.anotaion.ExecutedBy;
+import com.quark.quamera.camera.camera.Camera2CameraImpl;
+import com.quark.quamera.camera.camera.CameraState;
+import com.quark.quamera.camera.imagereader.DeferrableImageReader;
+import com.quark.quamera.camera.preview.IPreviewSurfaceProvider;
+import com.quark.quamera.util.CameraLogger;
+import com.quark.quamera.util.CameraShould;
+import com.quark.quamera.util.TestOnly;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Executor;
+
+import androidx.annotation.GuardedBy;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class SyncCaptureSession {
+
+
+ public static final String TAG = Camera2CameraImpl.TAG;
+ /**
+ * Lock on whether the camera is open or closed.
+ */
+ final Object mStateLock = new Object();
+
+ @GuardedBy("mStateLock")
+ private State mState = State.INITIALIZED;
+
+ private CameraCaptureSession mCameraCaptureSession;
+
+ private Camera2CameraImpl mCamera;
+
+ private Handler mHandler;
+
+ public SyncCaptureSession(Camera2CameraImpl camera, Handler handler) {
+ mCamera = camera;
+ mHandler = handler;
+ }
+
+
+ private CaptureRequest.Builder mCaptureRequestBuilder;
+
+ @GuardedBy("mStateLock")
+ private SessionConfig mSessionConfig;
+
+
+ enum State {
+ /**
+ * The default state of the session before construction.
+ */
+// UNINITIALIZED,
+ /**
+ * Stable state once the session has been constructed, but prior to the {@link
+ * CameraCaptureSession} being opened.
+ */
+ INITIALIZED,
+ /**
+ * Transitional state when the {@link CameraCaptureSession} is in the process of being
+ * opened.
+ */
+ OPENING,
+ /**
+ * SyncCaptureSession
+ * Stable state where the {@link CameraCaptureSession} has been successfully opened. During
+ * this state if a valid {@link SessionConfig} has been set then the {@link
+ * CaptureRequest} will be issued.
+ */
+ OPENED,
+
+ /**
+ * Transitional state where the resources are being cleaned up.
+ */
+ RELEASING,
+ /**
+ * Terminal state where the session has been cleaned up. At this point the session should
+ * not be used as nothing will happen in this state.
+ */
+ RELEASED
+ }
+
+
+ @TestOnly
+ private long mFPSTestTime = 0;
+
+ public void open(@NonNull CameraDevice cameraDevice, @NonNull SessionConfig config) {
+ synchronized (mStateLock) {
+ switch (mState) {
+ case INITIALIZED:
+ mSessionConfig = config;
+ openCaptureSession(cameraDevice);
+ break;
+ default:
+ CameraLogger.e(TAG, "Open not allowed in state: " + mState);
+ }
+ }
+ }
+
+ private void changeState(State newState) {
+ synchronized (mStateLock) {
+ mState = newState;
+ }
+ }
+
+ private final StateControlCallback mStateController = new StateControlCallback();
+
+ private final CaptureControlCallback mCaptureControlCallback = new CaptureControlCallback();
+
+ private void openCaptureSession(@NonNull CameraDevice cameraDevice) {
+ if (mSessionConfig == null) {
+ return;
+ }
+
+ try {
+
+ PreviewConfig previewConfig = mSessionConfig.getPreviewConfig();
+
+ IPreviewSurfaceProvider.SurfaceRequest request = new IPreviewSurfaceProvider.SurfaceRequest();
+ request.width = previewConfig.getActualWidth();
+ request.height = previewConfig.getActualHeight();
+ request.camera2Camera = mCamera;
+ request.repeatCaptureCallback = previewConfig.getRepeatCaptureCallback();
+
+ Surface previewSurface = previewConfig.getPreviewView().getSurfaceProvider().provide(request);
+
+ //创建CaptureRequestBuilder，TEMPLATE_PREVIEW比表示预览请求
+ mCaptureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
+ //设置Surface作为预览数据的显示界面
+
+ ArrayList surfaces = new ArrayList<>();
+ surfaces.add(previewSurface);
+
+ mCaptureRequestBuilder.addTarget(previewSurface);
+
+ if (mSessionConfig.getPreviewConfig().getImageReaders() != null) {
+ for (DeferrableImageReader imageReader : mSessionConfig.getPreviewConfig().getImageReaders()) {
+ if (imageReader.unWrapper() != null) {
+ surfaces.add(imageReader.unWrapper().getSurface());
+ CameraLogger.i(Camera2CameraImpl.TAG, "add ImageReader Surface begin ( format:%d, %d*%d )", imageReader.getFormat(), imageReader.unWrapper().getWidth(), imageReader.unWrapper().getHeight());
+ mCaptureRequestBuilder.addTarget(imageReader.unWrapper().getSurface());
+ }
+ }
+ }
+
+ ImageCapture captureConfig = mSessionConfig.getImageCapture();
+ if (captureConfig != null && captureConfig.getDeferrableImageReader() != null) {
+ surfaces.add(captureConfig.getDeferrableImageReader().unWrapper().getSurface());
+ }
+
+ CameraLogger.i(Camera2CameraImpl.TAG, "openCaptureSession begin ( preview: %d*%d )",
+ mSessionConfig.getPreviewConfig().getActualWidth(),
+ mSessionConfig.getPreviewConfig().getActualHeight());
+
+ changeState(State.OPENING);
+
+ cameraDevice.createCaptureSession(surfaces, mStateController, mHandler);
+ } catch (CameraAccessException e) {
+ CameraLogger.e(Camera2CameraImpl.TAG, "openCaptureSession error (%s) ", e.getMessage());
+ CameraShould.fail("", e);
+ }
+ }
+
+ public void capture(SingleCaptureConfig singleCaptureConfig, @NonNull CameraDevice cameraDevice, @NonNull InnerImageCaptureCallback capturedCallback) {
+ switch (mState) {
+ case OPENED:
+ captureInner(singleCaptureConfig, cameraDevice, capturedCallback);
+ break;
+ default:
+ if (capturedCallback != null) {
+ capturedCallback.onError(new IllegalStateException("can not capture image when " + mState));
+ }
+ }
+ }
+
+ private void captureInner(SingleCaptureConfig singleCaptureConfig, @NonNull CameraDevice cameraDevice,
+ @NonNull InnerImageCaptureCallback capturedCallback) {
+ try {
+
+ ImageCapture captureConfig = mSessionConfig.getImageCapture();
+
+ if (captureConfig == null) {
+ throw new RuntimeException("init image capture config first");
+ }
+
+
+ // This is the CaptureRequest.Builder that we use to take a picture.
+ final CaptureRequest.Builder captureBuilder =
+ cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
+
+ ImageReader actualImageReader = captureConfig.getDeferrableImageReader().unWrapper();
+ captureBuilder.addTarget(actualImageReader.getSurface());
+
+
+ int natureRotation = captureConfig.getDeferrableImageReader().getImageRotationHelper().getImageRotation();
+ int sensorRotation = captureConfig.getDeferrableImageReader().getImageRotationHelper().getCameraSensorOrientation();
+
+ int jpegRotation = sensorRotation;
+ if (singleCaptureConfig != null && singleCaptureConfig.useNatureRotation()) {
+ jpegRotation = natureRotation;
+ }
+ captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, jpegRotation);
+ captureBuilder.set(CaptureRequest.JPEG_QUALITY, singleCaptureConfig != null ?
+ singleCaptureConfig.getJpegQuality() : 100);
+ captureConfig.fillConfig(mCamera.getCameraCharacteristics(), captureBuilder);
+
+ //选择对应的相机，初始化默认配置
+ if (mSessionConfig.getSelectConfig() != null) {
+ mSessionConfig.getSelectConfig().fillConfig(mCamera.getCamera2Info(), captureBuilder);
+ }
+
+ //TODO NoBlockImageAnalyzer 相当于每次只有一个图片回掉,之前的回掉会给新触发的callback给替换掉
+ captureConfig.getDeferrableImageReader().getNoBlockImageAnalyzer().setImageAnalyzer((image, cameraSensorRotation, imageRotation) -> {
+ CameraLogger.i(Camera2CameraImpl.TAG, "ImageCapture Success (%d * %d)", image.getWidth(), image.getHeight());
+ capturedCallback.onCaptureSuccess(image);
+ });
+
+ CameraCaptureSession.CaptureCallback innerCallback = new CameraCaptureSession.CaptureCallback() {
+
+ @Override
+ public void onCaptureFailed(@NonNull CameraCaptureSession session,
+ @NonNull CaptureRequest request,
+ @NonNull CaptureFailure failure) {
+ super.onCaptureFailed(session, request, failure);
+ capturedCallback.onError(new Exception("capture_error:" + failure.getReason()));
+ }
+
+ @Override
+ public void onCaptureStarted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, long timestamp, long frameNumber) {
+ capturedCallback.onCaptureStart();
+ }
+
+ @Override
+ public void onCaptureSequenceAborted(@NonNull CameraCaptureSession session, int sequenceId) {
+ super.onCaptureSequenceAborted(session, sequenceId);
+ capturedCallback.onError(new Exception("capture_error:onCaptureSequenceAborted"));
+
+ }
+ };
+
+
+ //TODO 目前只有闪光等设置了需要关闭Repeating模式，重新开启
+ //但是这块改动影响了CameraCaptureState的逻辑，目前先不实现
+// mCameraCaptureSession.stopRepeating();
+// mCameraCaptureSession.abortCaptures();
+
+ int id = mCameraCaptureSession.capture(captureBuilder.build(), innerCallback, mHandler);
+
+ CameraLogger.i(Camera2CameraImpl.TAG, "send image capture request " + id);
+
+ } catch (CameraAccessException e) {
+ CameraLogger.e(Camera2CameraImpl.TAG, "openCaptureSession error (%s) ", e.getMessage());
+ CameraShould.fail("", e);
+ capturedCallback.onError(e);
+ }
+ }
+
+
+ /**
+ * Callback for handling state changes to the {@link CameraCaptureSession}.
+ *
+ * State changes are ignored once the CaptureSession has been closed.
+ */
+ final class StateControlCallback extends CameraCaptureSession.StateCallback {
+ /**
+ * {@inheritDoc}
+ *
+ *
Once the {@link CameraCaptureSession} has been configured then the capture request
+ * will be immediately issued.
+ */
+ @Override
+ public void onConfigured(@NonNull CameraCaptureSession session) {
+ synchronized (mStateLock) {
+ switch (mState) {
+ case INITIALIZED:
+ case OPENED:
+ case RELEASED:
+ throw new IllegalStateException(
+ "onConfigured() should not be possible in state: " + mState);
+ case OPENING:
+ if (mCamera.getCameraState() != CameraState.OPEN) {
+ //相机已经关闭了,直接关闭session
+ changeState(State.RELEASED);
+ return;
+ }
+ mState = State.OPENED;
+ changeState(State.OPENED);
+
+ mCameraCaptureSession = session;
+ CameraLogger.i("AndroidCameraApi", "Attempting to send capture request onConfigured");
+ issueRepeatingCaptureRequests(null);
+ break;
+ case RELEASING:
+ changeState(State.RELEASED);
+ session.close();
+ break;
+ }
+ CameraLogger.i(TAG, "CameraCaptureSession.onConfigured() mState=" + mState);
+ }
+ }
+
+ @Override
+ public void onReady(@NonNull CameraCaptureSession session) {
+ synchronized (mStateLock) {
+ switch (mState) {
+ case RELEASING:
+ if (mCameraCaptureSession == null) {
+ // No-op for releasing an unopened session.
+ break;
+ }
+ // The abortCaptures() called in release() has successfully finished.
+ mCameraCaptureSession.close();
+ break;
+ default:
+ }
+ CameraLogger.i(TAG, "CameraCaptureSession.onReady() " + mState);
+ }
+ }
+
+ @Override
+ public void onClosed(@NonNull CameraCaptureSession session) {
+ synchronized (mStateLock) {
+
+ if (mState == State.RELEASED) {
+ // If released then onClosed() has already been called, but it can be ignored
+ // since a session can be forceClosed.
+ return;
+ }
+
+ Log.d(TAG, "CameraCaptureSession.onClosed()");
+
+
+ changeState(State.RELEASED);
+ mCameraCaptureSession = null;
+
+ if (mSessionConfig != null) {
+ mSessionConfig.getPreviewConfig().getPreviewView().getSurfaceProvider().onUseComplete(null);
+ mSessionConfig = null;
+ }
+ }
+ }
+
+ @Override
+ public void onConfigureFailed(@NonNull CameraCaptureSession session) {
+ synchronized (mStateLock) {
+ switch (mState) {
+ case INITIALIZED:
+ case OPENED:
+ case RELEASED:
+ throw new IllegalStateException(
+ "onConfiguredFailed() should not be possible in state: " + mState);
+ case OPENING:
+ case RELEASING:
+ changeState(State.RELEASING);
+ session.close();
+ break;
+ }
+ CameraLogger.i(TAG, "CameraCaptureSession.onConfiguredFailed() " + mState);
+ }
+ }
+ }
+
+
+ public void doRepeatingCaptureAction(@NonNull RepeatCaptureRequestConfig config) {
+ mHandler.post(() -> {
+ switch (mState) {
+ case OPENED:
+ issueRepeatingCaptureRequests(config);
+ break;
+ default:
+ if (config.getCallback() != null) {
+ if (config.getCallbackExecutor() != null) {
+ config.getCallbackExecutor().execute(() -> config.getCallback().onCaptureFailed(new CameraCaptureFailure(CameraCaptureFailure.Reason.ERROR)));
+ } else {
+ config.getCallback().onCaptureFailed(new CameraCaptureFailure(CameraCaptureFailure.Reason.ERROR));
+ }
+ break;
+ }
+ }
+ });
+
+ }
+
+
+ private void issueRepeatingCaptureRequests(RepeatCaptureRequestConfig action) {
+ if (mSessionConfig == null) {
+ CameraLogger.e(TAG, "Skipping issueRepeatingCaptureRequests for no configuration case.");
+ return;
+ }
+
+ try {
+
+ //设置反复捕获数据的请求，这样预览界面就会一直有数据显示
+ List callbackList = new ArrayList<>();
+ callbackList.add(mCaptureControlCallback);
+
+
+ RepeatCaptureRequestConfig requestConfig = mSessionConfig.getPreviewConfig().getRepeatCaptureRequestConfig();
+ requestConfig.fillConfig(mCamera.getCamera2Info(), mCaptureRequestBuilder);
+
+ callbackList.add(convert2SystemApiCaptureCallback(requestConfig.getCallbackExecutor(), requestConfig.getCallback()));
+
+
+ if (action != null) {
+ callbackList.add(convert2SystemApiCaptureCallback(action.getCallbackExecutor(), action.getCallback()));
+ action.fillConfig(mCamera.getCamera2Info(), mCaptureRequestBuilder);
+ }
+
+ //选择对应的相机，初始化默认配置
+ if (mSessionConfig.getSelectConfig() != null) {
+ mSessionConfig.getSelectConfig().fillConfig(mCamera.getCamera2Info(), mCaptureRequestBuilder);
+ }
+
+ //创建捕获请求
+ CaptureRequest request = mCaptureRequestBuilder.build();
+
+
+ ComboSessionCaptureCallback comboSessionCaptureCallback = new ComboSessionCaptureCallback(callbackList);
+
+ if (mCamera.getCameraState() == CameraState.OPEN) {
+ mCameraCaptureSession.setRepeatingRequest(request, comboSessionCaptureCallback, mHandler);
+ }
+
+ } catch (CameraAccessException e) {
+ CameraLogger.e(Camera2CameraImpl.TAG, "CameraCaptureSession.openCaptureSession error (%s) ", e.getMessage());
+ CameraShould.fail("", e);
+ }
+ }
+
+
+ /**
+ * Releases the capture session.
+ *
+ * This releases all of the sessions resources and should be called when ready to close the
+ * camera.
+ *
+ *
Once a session is released it can no longer be opened again. After the session is released
+ * all method calls on it do nothing.
+ */
+ @ExecutedBy("mHandler")
+ public void release() {
+ synchronized (mStateLock) {
+ CameraLogger.i(Camera2CameraImpl.TAG, "CameraCaptureSession.releaseCaptureSession when (%s) %s ", mState, mCameraCaptureSession);
+ switch (mState) {
+ case OPENED:
+ if (mCameraCaptureSession != null) {
+ mCameraCaptureSession.close();
+ }
+ // Fall through
+ case OPENING:
+ mState = State.RELEASING;
+ // Fall through
+ case RELEASING:
+ break;
+ case INITIALIZED:
+ mState = State.RELEASED;
+ // Fall through
+ case RELEASED:
+ break;
+ }
+ }
+ }
+
+ @ExecutedBy("mHandler")
+ public void forceRelease() {
+ synchronized (mStateLock) {
+ if (mSessionConfig != null) {
+ mSessionConfig.getPreviewConfig()
+ .getPreviewView()
+ .getSurfaceProvider()
+ .onUseComplete(null);
+ if (mSessionConfig.getImageCapture() != null
+ && mSessionConfig.getImageCapture().getDeferrableImageReader() != null) {
+ mSessionConfig.getImageCapture().getDeferrableImageReader().safeClose();
+ }
+ mSessionConfig = null;
+ }
+ }
+ }
+
+ private static CameraCaptureSession.CaptureCallback convert2SystemApiCaptureCallback(Executor executor, CameraCaptureCallback callback) {
+ if (callback == null) {
+ return null;
+ }
+ if (executor == null) {
+ return new CaptureCallbackAdapter(callback);
+ }
+
+
+ return new CaptureCallbackHandlerWrapper(executor, new CaptureCallbackAdapter(callback));
+ }
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/UserCameraSession.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/UserCameraSession.java
new file mode 100644
index 000000000..b6432858f
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/UserCameraSession.java
@@ -0,0 +1,109 @@
+package com.quark.quamera.camera.session;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-23
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.os.Build;
+
+import com.quark.quamera.camera.camera.Camera2Info;
+import com.quark.quamera.camera.camera.CameraLifeManager;
+import com.quark.quamera.camera.camera.CameraState;
+import com.quark.quamera.camera.session.config.CameraSelectConfig;
+
+import java.util.concurrent.Executor;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.lifecycle.MutableLiveData;
+
+
+/**
+ * 不直接通过open,close的行为来直接使用相机,而是通过抽象窗口Session,使用Session的生命事件来控制相机
+ *
+ * {@link IUserCameraSession#active()} 开启相机
+ * {@link IUserCameraSession#inactive()} 关闭相机
+ */
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public final class UserCameraSession implements IUserCameraSession {
+
+ private State mState = State.INACTIVE;
+
+ private CameraSelector mCameraSelector;
+
+ private final CameraLifeManager mCameraLifeManager;
+
+ private final SessionConfig mSessionConfig;
+
+
+ public UserCameraSession(@NonNull CameraLifeManager cameraLifeManager, @NonNull SessionConfig sessionConfig) {
+ mCameraLifeManager = cameraLifeManager;
+ mSessionConfig = sessionConfig;
+ }
+
+ public UserCameraSession setCameraSelector(CameraSelector cameraSelector) {
+ mCameraSelector = cameraSelector;
+ return this;
+ }
+
+
+ private boolean openCamera() {
+ if (mCameraSelector == null) {
+ return false;
+ }
+ mSessionConfig.setSelectConfig(new CameraSelectConfig(mCameraSelector));
+ return mCameraLifeManager.openCamera(mCameraSelector, mSessionConfig);
+ }
+
+ public Camera2Info getCamera2Info() {
+ return mCameraLifeManager.getCamera2Info();
+ }
+
+ public void enableFlash(boolean enable, CameraCaptureCallback callback, Executor executor) {
+ mCameraLifeManager.enableFlash(enable, callback, executor);
+ }
+
+ public void takePicture(@NonNull SingleCaptureConfig singleCaptureConfig,
+ @NonNull ImageCapture.OnImageCapturedCallback capturedCallback) {
+ mCameraLifeManager.takePicture(singleCaptureConfig, capturedCallback);
+ }
+
+ public void closeCamera() {
+ mCameraLifeManager.closeCamera();
+ }
+
+ public @Nullable
+ MutableLiveData getCameraState() {
+ return mCameraLifeManager.getCurrentCameraState();
+ }
+
+
+ @Override
+ public boolean active() {
+ if (mState == State.ACTIVE) {
+ return false;
+ }
+ mState = State.ACTIVE;
+ return openCamera();
+ }
+
+
+ @Override
+ public boolean inactive() {
+ if (mState == State.INACTIVE) {
+ return false;
+ }
+ mState = State.INACTIVE;
+ closeCamera();
+ return true;
+ }
+
+ @Override
+ public boolean isActive() {
+ return mState == State.ACTIVE;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/config/CameraConfigUtils.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/config/CameraConfigUtils.java
new file mode 100644
index 000000000..8434c6e68
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/config/CameraConfigUtils.java
@@ -0,0 +1,36 @@
+package com.quark.quamera.camera.session.config;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/6/30
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraMetadata;
+import android.hardware.camera2.CaptureRequest;
+import android.os.Build;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import com.quark.quamera.util.ArrayUtil;
+
+public class CameraConfigUtils {
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ public static boolean checkAndSetConfigIntValue(@NonNull CameraCharacteristics characteristics,
+ @NonNull CaptureRequest.Builder builder,
+ @NonNull CameraCharacteristics.Key supportListKey,
+ @NonNull CaptureRequest.Key key,
+ @NonNull Integer expectValue) {
+
+ int[] support_values = characteristics.get(supportListKey);
+ int index = ArrayUtil.search(support_values, expectValue);
+ if (index != -1) {
+ builder.set(key, expectValue);
+ return true;
+ }
+ return false;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/config/CameraSelectConfig.java b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/config/CameraSelectConfig.java
new file mode 100644
index 000000000..e2c9cb65d
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camera/session/config/CameraSelectConfig.java
@@ -0,0 +1,62 @@
+package com.quark.quamera.camera.session.config;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/5/7
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CaptureRequest;
+import android.os.Build;
+
+import com.quark.quamera.camera.camera.Camera2Info;
+import com.quark.quamera.camera.session.CameraSelector;
+import com.quark.quamera.util.CameraLogger;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+
+public class CameraSelectConfig {
+
+ private final @NonNull
+ CameraSelector mCameraSelector;
+
+ public CameraSelectConfig(@NonNull CameraSelector cameraSelector) {
+ mCameraSelector = cameraSelector;
+ }
+
+ public void fillConfig(@NonNull Camera2Info cameraInfo,
+ @NonNull CaptureRequest.Builder builder) {
+
+
+ CameraCharacteristics cameraCharacteristics = cameraInfo.getCameraCharacteristics();
+
+ Camera2Info.FocalLengthInfo minFocalInfo = cameraInfo.getBestFocalInfo();
+
+
+ if (mCameraSelector.isUseWideCamera()) {
+ // if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
+ // Range zoom_range = cameraCharacteristics.get(CameraCharacteristics.CONTROL_ZOOM_RATIO_RANGE);
+ //
+ // } else
+ if (minFocalInfo != null) {
+ float focal_length = minFocalInfo.focalLength;
+ builder.set(CaptureRequest.LENS_FOCAL_LENGTH, focal_length);
+ CameraLogger.i("CameraLifeManager", "camera (%s) set focal_length %f", cameraInfo.getCameraId(), focal_length);
+ }
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+ // int[] cameraCharacteristics.get(CameraCharacteristics.DISTORTION_CORRECTION_AVAILABLE_MODES);
+ }
+ // builder.set(CaptureRequest.SCALER_CROP_REGION,);
+
+
+ }
+ }
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/CameraController.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/CameraController.java
new file mode 100644
index 000000000..098ab8565
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/CameraController.java
@@ -0,0 +1,1245 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camerax;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.graphics.ImageFormat;
+import android.graphics.Rect;
+import android.hardware.camera2.CaptureResult;
+import android.hardware.display.DisplayManager;
+import android.os.Build;
+import android.util.Log;
+import android.util.Size;
+import android.view.Display;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.quark.quamera.camerax.controller.ForwardingLiveData;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+
+import androidx.annotation.FloatRange;
+import androidx.annotation.IntDef;
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.camera.core.AspectRatio;
+import androidx.camera.core.Camera;
+import androidx.camera.core.CameraControl;
+import androidx.camera.core.CameraInfo;
+import androidx.camera.core.CameraInfoUnavailableException;
+import androidx.camera.core.CameraSelector;
+import androidx.camera.core.FocusMeteringAction;
+import androidx.camera.core.FocusMeteringResult;
+import androidx.camera.core.ImageAnalysis;
+import androidx.camera.core.ImageCapture;
+import androidx.camera.core.ImageProxy;
+import androidx.camera.core.Logger;
+import androidx.camera.core.MeteringPoint;
+import androidx.camera.core.MeteringPointFactory;
+import androidx.camera.core.Preview;
+import androidx.camera.core.UseCase;
+import androidx.camera.core.UseCaseGroup;
+import androidx.camera.core.ViewPort;
+import androidx.camera.core.ZoomState;
+import androidx.camera.core.impl.CameraInfoInternal;
+import androidx.camera.core.impl.CameraInternal;
+import androidx.camera.core.impl.ImageOutputConfig;
+import androidx.camera.core.impl.Observable;
+import androidx.camera.core.impl.utils.Threads;
+import androidx.camera.core.impl.utils.executor.CameraXExecutors;
+import androidx.camera.core.impl.utils.futures.FutureCallback;
+import androidx.camera.core.impl.utils.futures.Futures;
+import androidx.camera.lifecycle.ProcessCameraProvider;
+import androidx.core.util.Preconditions;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public abstract class CameraController {
+
+ private static final String TAG = "CameraController";
+
+ // Externally visible error messages.
+ private static final String CAMERA_NOT_INITIALIZED = "Camera not initialized.";
+ private static final String PREVIEW_VIEW_NOT_ATTACHED = "PreviewView not attached.";
+ private static final String CAMERA_NOT_ATTACHED = "Use cases not attached to camera.";
+ private static final String IMAGE_CAPTURE_DISABLED = "ImageCapture disabled.";
+
+ // Auto focus is 1/6 of the area.
+ private static final float AF_SIZE = 1.0f / 6.0f;
+ private static final float AE_SIZE = AF_SIZE * 1.5f;
+
+
+ @Retention(RetentionPolicy.SOURCE)
+ @RestrictTo(RestrictTo.Scope.LIBRARY)
+ @IntDef(value = {TAP_TO_FOCUS_NOT_STARTED, TAP_TO_FOCUS_STARTED, TAP_TO_FOCUS_SUCCESSFUL,
+ TAP_TO_FOCUS_UNSUCCESSFUL, TAP_TO_FOCUS_FAILED})
+ public @interface TapToFocusStates {
+ }
+
+ /**
+ * No tap-to-focus action has been started by the end user.
+ */
+ public static final int TAP_TO_FOCUS_NOT_STARTED = 0;
+
+ /**
+ * A tap-to-focus action has started but not completed. The app also gets notified with this
+ * state if a new action happens before the previous one could finish.
+ */
+ public static final int TAP_TO_FOCUS_STARTED = 1;
+
+ /**
+ * The previous tap-to-focus action was completed successfully and the camera is focused.
+ */
+ public static final int TAP_TO_FOCUS_SUCCESSFUL = 2;
+
+ /**
+ * The previous tap-to-focus action was completed successfully but the camera is still
+ * unfocused. It happens when CameraX receives
+ * {@link CaptureResult#CONTROL_AF_STATE_NOT_FOCUSED_LOCKED}. The end user might be able to
+ * get a better result by trying again with different camera distances and/or lighting.
+ */
+ public static final int TAP_TO_FOCUS_UNSUCCESSFUL = 3;
+
+ /**
+ * The previous tap-to-focus action was failed to complete. This is usually due to device
+ * limitations.
+ */
+ public static final int TAP_TO_FOCUS_FAILED = 4;
+
+ /**
+ * Bitmask options to enable/disable use cases.
+ *
+ * @hide
+ */
+ @Retention(RetentionPolicy.SOURCE)
+ @RestrictTo(RestrictTo.Scope.LIBRARY)
+ @IntDef(flag = true, value = {IMAGE_CAPTURE, IMAGE_ANALYSIS, VIDEO_CAPTURE})
+ public @interface UseCases {
+ }
+
+ /**
+ * Bitmask option to enable {@link ImageCapture}. In {@link #setEnabledUseCases}, if
+ * (enabledUseCases & IMAGE_CAPTURE) != 0, then controller will enable image capture features.
+ */
+ public static final int IMAGE_CAPTURE = 1;
+ /**
+ * Bitmask option to enable {@link ImageAnalysis}. In {@link #setEnabledUseCases}, if
+ * (enabledUseCases & IMAGE_ANALYSIS) != 0, then controller will enable image analysis features.
+ */
+ public static final int IMAGE_ANALYSIS = 1 << 1;
+ /**
+ * Bitmask option to enable video capture use case. In {@link #setEnabledUseCases}, if
+ * (enabledUseCases & VIDEO_CAPTURE) != 0, then controller will enable video capture features.
+ */
+ public static final int VIDEO_CAPTURE = 1 << 2;
+
+ CameraSelector mCameraSelector = CameraSelector.DEFAULT_BACK_CAMERA;
+
+ // By default, ImageCapture and ImageAnalysis are enabled. VideoCapture is disabled.
+ private int mEnabledUseCases = IMAGE_CAPTURE;
+
+ // CameraController and PreviewView hold reference to each other. The 2-way link is managed
+ // by PreviewView.
+ // Synthetic access
+ @SuppressWarnings("WeakerAccess")
+ @NonNull
+ Preview mPreview;
+
+ @Nullable
+ OutputSize mPreviewTargetSize;
+
+ // Synthetic access
+ @SuppressWarnings("WeakerAccess")
+ @NonNull
+ ImageCapture mImageCapture;
+
+ @Nullable
+ OutputSize mImageCaptureTargetSize;
+
+ @Nullable
+ Executor mImageCaptureIoExecutor;
+
+ @NonNull
+ ImageAnalysis mImageAnalysis;
+
+ @SuppressWarnings("WeakerAccess")
+ @Nullable
+ Camera mCamera;
+
+ // Synthetic access
+ @SuppressWarnings("WeakerAccess")
+ @Nullable
+ ProcessCameraProvider mCameraProvider;
+
+ // Synthetic access
+ @SuppressWarnings("WeakerAccess")
+ @Nullable
+ ViewPort mViewPort;
+
+ // Synthetic access
+ @SuppressWarnings("WeakerAccess")
+ @Nullable
+ Preview.SurfaceProvider mSurfaceProvider;
+
+ // Synthetic access
+ @SuppressWarnings("WeakerAccess")
+ @Nullable
+ Display mPreviewDisplay;
+
+ /**
+ * 缩放和轻点对焦的开关
+ */
+ private boolean mPinchToZoomEnabled = true;
+ private boolean mTapToFocusEnabled = true;
+
+ private final ForwardingLiveData mZoomState = new ForwardingLiveData<>();
+ private final ForwardingLiveData mTorchState = new ForwardingLiveData<>();
+ private final MutableLiveData mCameraInfoLiveData = new MutableLiveData<>();
+ private final MutableLiveData mCameraControlLiveData = new MutableLiveData<>();
+ private final MutableLiveData> mStateLiveData = new ForwardingLiveData<>();
+ // Synthetic access
+ @SuppressWarnings("WeakerAccess")
+ final MutableLiveData mTapToFocusState = new MutableLiveData<>(
+ TAP_TO_FOCUS_NOT_STARTED);
+
+ protected final Context mAppContext;
+
+ @NonNull
+ private final ListenableFuture mInitializationFuture;
+
+ private static final Size CAPTURE_MAX_SIZE = new Size(3456, 4608);
+ private static final Size PREVIEW_MAX_SIZE = new Size(1500, 2000);
+
+ private static final Size CAPTURE_TARGET_SIZE = new Size(3000, 4000);
+
+
+ CameraController(@NonNull Context context, Size previewView) {
+ this(context, previewView, true, null, null);
+ }
+
+ @SuppressLint("RestrictedApi")
+ CameraController(@NonNull Context context, Size previewSize, boolean isLimitCaptureSize, Size maxCaptureSize, @Nullable OnCameraProviderListener listener) {
+ mAppContext = getApplicationContext(context);
+ Preview.Builder builder = new Preview.Builder();
+ if (previewSize != null) {
+ builder.setTargetResolution(new Size(previewSize.getHeight(), previewSize.getWidth()));
+ } else {
+ builder.setTargetAspectRatio(AspectRatio.RATIO_4_3);
+ }
+ mPreview = builder.setMaxResolution(PREVIEW_MAX_SIZE).build();
+
+ if (maxCaptureSize == null) {
+ maxCaptureSize = CAPTURE_MAX_SIZE;
+ }
+ ImageCapture.Builder captureBuilder = new ImageCapture.Builder()
+ .setMaxResolution(maxCaptureSize)
+ .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
+ .setBufferFormat(ImageFormat.JPEG);
+ if (isLimitCaptureSize) {
+ // 指定拍摄分辨率为3000 * 4000
+ captureBuilder.setTargetResolution(CAPTURE_TARGET_SIZE);
+ } else {
+ captureBuilder.setTargetAspectRatio(AspectRatio.RATIO_4_3);
+ }
+
+ mImageCapture = captureBuilder.build();
+ mImageAnalysis = new ImageAnalysis.Builder().build();
+
+ // Wait for camera to be initialized before binding use cases.
+ mInitializationFuture = Futures.transform(
+ ProcessCameraProvider.getInstance(mAppContext),
+ provider -> {
+ mCameraProvider = provider;
+ // 用于外层在开启相机前获取某个cameraId的配置
+ if (listener != null) {
+ listener.onProcessCameraProvider(provider);
+ }
+ startCameraAndTrackStates();
+ return null;
+ }, CameraXExecutors.mainThreadExecutor());
+ }
+
+ /**
+ * Gets the application context and preserves the attribution tag.
+ *
+ * TODO(b/185272953): instrument test getting attribution tag once the view artifact depends
+ * on a core version that has the fix.
+ */
+ private static Context getApplicationContext(@NonNull Context context) {
+ Context applicationContext = context.getApplicationContext();
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+ String attributeTag = Api30Impl.getAttributionTag(context);
+
+ if (attributeTag != null) {
+ return Api30Impl.createAttributionContext(applicationContext, attributeTag);
+ }
+ }
+
+ return applicationContext;
+ }
+
+ @NonNull
+ public ListenableFuture getInitializationFuture() {
+ return mInitializationFuture;
+ }
+
+ /**
+ * Implemented by children to refresh after {@link UseCase} is changed.
+ *
+ * @return
+ */
+ @Nullable
+ abstract Camera startCamera();
+
+ private boolean isCameraInitialized() {
+ return mCameraProvider != null;
+ }
+
+ private boolean isPreviewViewAttached() {
+ return mSurfaceProvider != null && mViewPort != null && mPreviewDisplay != null;
+ }
+
+ public boolean isCameraAttached() {
+ return mCamera != null;
+ }
+
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public void setEnabledUseCases(@UseCases int enabledUseCases) {
+ Threads.checkMainThread();
+ if (enabledUseCases == mEnabledUseCases) {
+ return;
+ }
+ int oldEnabledUseCases = mEnabledUseCases;
+ mEnabledUseCases = enabledUseCases;
+ startCameraAndTrackStates(() -> mEnabledUseCases = oldEnabledUseCases);
+ }
+
+ /**
+ * Checks if the given use case mask is enabled.
+ *
+ * @param useCaseMask One of the {@link #IMAGE_CAPTURE}, {@link #IMAGE_ANALYSIS} or
+ * {@link #VIDEO_CAPTURE}
+ * @return true if the use case is enabled.
+ */
+ private boolean isUseCaseEnabled(int useCaseMask) {
+ return (mEnabledUseCases & useCaseMask) != 0;
+ }
+
+ /**
+ * Sets the target aspect ratio or target resolution based on {@link OutputSize}.
+ */
+ @SuppressLint("RestrictedApi")
+ private void setTargetOutputSize(@NonNull ImageOutputConfig.Builder builder,
+ @Nullable OutputSize outputSize) {
+ if (outputSize == null) {
+ return;
+ }
+ if (outputSize.getResolution() != null) {
+ builder.setTargetResolution(outputSize.getResolution());
+ } else if (outputSize.getAspectRatio() != OutputSize.UNASSIGNED_ASPECT_RATIO) {
+ builder.setTargetAspectRatio(outputSize.getAspectRatio());
+ } else {
+ Logger.e(TAG, "Invalid target surface size. " + outputSize);
+ }
+ }
+
+ /**
+ * Checks if two {@link OutputSize} are equal.
+ */
+ private boolean isOutputSizeEqual(
+ @Nullable OutputSize currentSize,
+ @Nullable OutputSize newSize) {
+ if (currentSize == newSize) {
+ return true;
+ }
+ return currentSize != null && currentSize.equals(newSize);
+ }
+
+ // ------------------
+ // Preview use case.
+ // ------------------
+
+ @SuppressLint({"MissingPermission", "WrongConstant", "RestrictedApi"})
+ @MainThread
+ public void attachPreviewSurface(@NonNull Preview.SurfaceProvider surfaceProvider,
+ @NonNull ViewPort viewPort, @NonNull Display display) {
+ Threads.checkMainThread();
+ if (mSurfaceProvider != surfaceProvider) {
+ mSurfaceProvider = surfaceProvider;
+ mPreview.setSurfaceProvider(surfaceProvider);
+ }
+ mViewPort = viewPort;
+ mPreviewDisplay = display;
+ startCameraAndTrackStates();
+ }
+
+
+ @MainThread
+ public void clearPreviewSurface() {
+ if (mCameraProvider != null) {
+ // Preview is required. Unbind everything if Preview is down.
+ mCameraProvider.unbindAll();
+ }
+ mPreview.setSurfaceProvider(null);
+ mCamera = null;
+ mSurfaceProvider = null;
+ mViewPort = null;
+ mPreviewDisplay = null;
+ }
+
+ private DisplayManager getDisplayManager() {
+ return (DisplayManager) mAppContext.getSystemService(Context.DISPLAY_SERVICE);
+ }
+
+
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public void setPreviewTargetSize(@Nullable OutputSize targetSize) {
+ Threads.checkMainThread();
+ if (isOutputSizeEqual(mPreviewTargetSize, targetSize)) {
+ return;
+ }
+ mPreviewTargetSize = targetSize;
+ unbindPreviewAndRecreate();
+ startCameraAndTrackStates();
+ }
+
+ /**
+ * Returns the intended output size for {@link Preview} set by
+ * {@link #setPreviewTargetSize(OutputSize)}, or null if not set.
+ */
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ @Nullable
+ public OutputSize getPreviewTargetSize() {
+ Threads.checkMainThread();
+ return mPreviewTargetSize;
+ }
+
+ /**
+ * Unbinds {@link Preview} and recreates with the latest parameters.
+ */
+ private void unbindPreviewAndRecreate() {
+ if (isCameraInitialized()) {
+ mCameraProvider.unbind(mPreview);
+ }
+ Preview.Builder builder = new Preview.Builder();
+ setTargetOutputSize(builder, mPreviewTargetSize);
+ mPreview = builder.build();
+ }
+
+ // ----------------------
+ // ImageCapture UseCase.
+ // ----------------------
+
+ /**
+ * Checks if {@link ImageCapture} is enabled.
+ *
+ * {@link ImageCapture} is enabled by default. It has to be enabled before
+ * {@link #takePicture} can be called.
+ *
+ * @see ImageCapture
+ */
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public boolean isImageCaptureEnabled() {
+ Threads.checkMainThread();
+ return isUseCaseEnabled(IMAGE_CAPTURE);
+ }
+
+ /**
+ * Gets the flash mode for {@link ImageCapture}.
+ *
+ * @return the flashMode. Value is {@link ImageCapture#FLASH_MODE_AUTO},
+ * {@link ImageCapture#FLASH_MODE_ON}, or {@link ImageCapture#FLASH_MODE_OFF}.
+ * @see ImageCapture
+ */
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ @ImageCapture.FlashMode
+ public int getImageCaptureFlashMode() {
+ Threads.checkMainThread();
+ return mImageCapture.getFlashMode();
+ }
+
+ /**
+ * Sets the flash mode for {@link ImageCapture}.
+ *
+ *
If not set, the flash mode will default to {@link ImageCapture#FLASH_MODE_OFF}.
+ *
+ * @param flashMode the flash mode for {@link ImageCapture}.
+ */
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public void setImageCaptureFlashMode(@ImageCapture.FlashMode int flashMode) {
+ Threads.checkMainThread();
+ mImageCapture.setFlashMode(flashMode);
+ }
+
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public void takePicture(
+ @NonNull ImageCapture.OutputFileOptions outputFileOptions,
+ @NonNull Executor executor,
+ @NonNull ImageCapture.OnImageSavedCallback imageSavedCallback,
+ Rect viewPortCropRect) {
+ Threads.checkMainThread();
+ Preconditions.checkState(isCameraInitialized(), CAMERA_NOT_INITIALIZED);
+ Preconditions.checkState(isImageCaptureEnabled(), IMAGE_CAPTURE_DISABLED);
+
+ mImageCapture.setViewPortCropRect(viewPortCropRect);
+ takePicture(outputFileOptions, executor, imageSavedCallback);
+ }
+
+
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public void takePicture(
+ @NonNull ImageCapture.OutputFileOptions outputFileOptions,
+ @NonNull Executor executor,
+ @NonNull ImageCapture.OnImageSavedCallback imageSavedCallback) {
+
+ Threads.checkMainThread();
+ Preconditions.checkState(isCameraInitialized(), CAMERA_NOT_INITIALIZED);
+ Preconditions.checkState(isImageCaptureEnabled(), IMAGE_CAPTURE_DISABLED);
+
+ updateMirroringFlagInOutputFileOptions(outputFileOptions);
+ mImageCapture.takePicture(outputFileOptions, executor, imageSavedCallback);
+ }
+
+ /**
+ * Update {@link ImageCapture.OutputFileOptions} based on config.
+ *
+ *
Mirror the output image if front camera is used and if the flag is not set explicitly by
+ * the app.
+ *
+ * @hide
+ */
+ @SuppressLint("RestrictedApi")
+ @VisibleForTesting
+ @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+ void updateMirroringFlagInOutputFileOptions(
+ @NonNull ImageCapture.OutputFileOptions outputFileOptions) {
+ if (mCameraSelector.getLensFacing() != null
+ && !outputFileOptions.getMetadata().isReversedHorizontalSet()) {
+ outputFileOptions.getMetadata().setReversedHorizontal(
+ mCameraSelector.getLensFacing() == CameraSelector.LENS_FACING_FRONT);
+ }
+ }
+
+ /**
+ * Captures a new still image for in memory access.
+ *
+ *
The listener is responsible for calling {@link ImageProxy#close()} on the returned image.
+ *
+ * @param executor The executor in which the callback methods will be run.
+ * @param callback Callback to be invoked for the newly captured image
+ * @see ImageCapture#takePicture(Executor, ImageCapture.OnImageCapturedCallback)
+ */
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public void takePicture(
+ @NonNull Executor executor,
+ @NonNull ImageCapture.OnImageCapturedCallback callback) {
+ Threads.checkMainThread();
+ Preconditions.checkState(isCameraInitialized(), CAMERA_NOT_INITIALIZED);
+ Preconditions.checkState(isImageCaptureEnabled(), IMAGE_CAPTURE_DISABLED);
+ mImageCapture.takePicture(executor, callback);
+ }
+
+ /**
+ * Sets the image capture mode.
+ *
+ *
Valid capture modes are {@link ImageCapture.CaptureMode#CAPTURE_MODE_MINIMIZE_LATENCY},
+ * which prioritizes latency over image quality, or
+ * {@link ImageCapture.CaptureMode#CAPTURE_MODE_MAXIMIZE_QUALITY},
+ * which prioritizes image quality over latency.
+ *
+ * @param captureMode the requested image capture mode.
+ */
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public void setImageCaptureMode(@ImageCapture.CaptureMode int captureMode) {
+ Threads.checkMainThread();
+ if (mImageCapture.getCaptureMode() == captureMode) {
+ return;
+ }
+ unbindImageCaptureAndRecreate(captureMode);
+ startCameraAndTrackStates();
+ }
+
+ /**
+ * Returns the image capture mode.
+ *
+ * @see ImageCapture#getCaptureMode()
+ */
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public int getImageCaptureMode() {
+ Threads.checkMainThread();
+ return mImageCapture.getCaptureMode();
+ }
+
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public void setImageCaptureTargetSize(@Nullable OutputSize targetSize) {
+ Threads.checkMainThread();
+ if (isOutputSizeEqual(mImageCaptureTargetSize, targetSize)) {
+ return;
+ }
+ mImageCaptureTargetSize = targetSize;
+ unbindImageCaptureAndRecreate(getImageCaptureMode());
+ startCameraAndTrackStates();
+ }
+
+ /**
+ * Returns the intended output size for {@link ImageCapture} set by
+ * {@link #setImageCaptureTargetSize(OutputSize)}, or null if not set.
+ */
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ @Nullable
+ public OutputSize getImageCaptureTargetSize() {
+ Threads.checkMainThread();
+ return mImageCaptureTargetSize;
+ }
+
+ /**
+ * Sets the default executor that will be used for {@link ImageCapture} IO tasks.
+ *
+ *
This executor will be used for any IO tasks specifically for {@link ImageCapture},
+ * such as {@link #takePicture(ImageCapture.OutputFileOptions, Executor,
+ * ImageCapture.OnImageSavedCallback)}. If no executor is set, then a default Executor
+ * specifically for IO will be used instead.
+ *
+ * @param executor The executor which will be used for IO tasks.
+ * TODO(b/187842789) add @see link for ImageCapture.
+ */
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public void setImageCaptureIoExecutor(@Nullable Executor executor) {
+ Threads.checkMainThread();
+ if (mImageCaptureIoExecutor == executor) {
+ return;
+ }
+ mImageCaptureIoExecutor = executor;
+ unbindImageCaptureAndRecreate(mImageCapture.getCaptureMode());
+ startCameraAndTrackStates();
+ }
+
+
+ /**
+ * Unbinds {@link ImageCapture} and recreates with the latest parameters.
+ */
+ private void unbindImageCaptureAndRecreate(int imageCaptureMode) {
+ if (isCameraInitialized()) {
+ mCameraProvider.unbind(mImageCapture);
+ }
+ ImageCapture.Builder builder = new ImageCapture.Builder().setCaptureMode(imageCaptureMode);
+ setTargetOutputSize(builder, mImageCaptureTargetSize);
+ if (mImageCaptureIoExecutor != null) {
+ builder.setIoExecutor(mImageCaptureIoExecutor);
+ }
+ mImageCapture = builder.build();
+ }
+
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public boolean isImageAnalysisEnabled() {
+ Threads.checkMainThread();
+ return isUseCaseEnabled(IMAGE_ANALYSIS);
+ }
+
+ // -----------------
+ // Camera control
+ // -----------------
+
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public void initCameraSelector(@NonNull CameraSelector cameraSelector) {
+ Threads.checkMainThread();
+ if (mCameraSelector == cameraSelector) {
+ return;
+ }
+ mCameraSelector = cameraSelector;
+ }
+
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public void setCameraSelector(@NonNull CameraSelector cameraSelector) {
+ Threads.checkMainThread();
+ if (mCameraSelector == cameraSelector) {
+ return;
+ }
+
+ CameraSelector oldCameraSelector = mCameraSelector;
+ mCameraSelector = cameraSelector;
+
+ if (mCameraProvider == null) {
+ return;
+ }
+ mCameraProvider.unbindAll();
+ startCameraAndTrackStates(() -> mCameraSelector = oldCameraSelector);
+ }
+
+ /**
+ * Checks if the given {@link CameraSelector} can be resolved to a camera.
+ *
+ *
Use this method to check if the device has the given camera.
+ *
+ *
Only call this method after camera is initialized. e.g. after the
+ * {@link ListenableFuture} from {@link #getInitializationFuture()} is finished. Calling it
+ * prematurely throws {@link IllegalStateException}. Example:
+ *
+ *
+ * controller.getInitializationFuture().addListener(() -> {
+ * if (controller.hasCamera(cameraSelector)) {
+ * controller.setCameraSelector(cameraSelector);
+ * } else {
+ * // Update UI if the camera is not available.
+ * }
+ * // Attach PreviewView after we know the camera is available.
+ * previewView.setController(controller);
+ * }, ContextCompat.getMainExecutor(requireContext()));
+ *
+ *
+ * @return true if the {@link CameraSelector} can be resolved to a camera.
+ * @throws IllegalStateException if the camera is not initialized.
+ */
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public boolean hasCamera(@NonNull CameraSelector cameraSelector) {
+ Threads.checkMainThread();
+ Preconditions.checkNotNull(cameraSelector);
+
+ if (mCameraProvider == null) {
+ throw new IllegalStateException("Camera not initialized. Please wait for "
+ + "the initialization future to finish. See #getInitializationFuture().");
+ }
+
+ try {
+ return mCameraProvider.hasCamera(cameraSelector);
+ } catch (CameraInfoUnavailableException e) {
+ Logger.w(TAG, "Failed to check camera availability", e);
+ return false;
+ }
+ }
+
+ /**
+ * Gets the {@link CameraSelector}.
+ *
+ * The default value is{@link CameraSelector#DEFAULT_BACK_CAMERA}.
+ *
+ * @see CameraSelector
+ */
+ @SuppressLint("RestrictedApi")
+ @NonNull
+ @MainThread
+ public CameraSelector getCameraSelector() {
+ Threads.checkMainThread();
+ return mCameraSelector;
+ }
+
+ /**
+ * Returns whether pinch-to-zoom is enabled.
+ *
+ *
By default pinch-to-zoom is enabled.
+ *
+ * @return True if pinch-to-zoom is enabled.
+ */
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public boolean isPinchToZoomEnabled() {
+ Threads.checkMainThread();
+ return mPinchToZoomEnabled;
+ }
+
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public void setPinchToZoomEnabled(boolean enabled) {
+ Threads.checkMainThread();
+ mPinchToZoomEnabled = enabled;
+ }
+
+
+ @SuppressLint("RestrictedApi")
+ @SuppressWarnings("FutureReturnValueIgnored")
+ public void onPinchToZoom(float pinchToZoomScale) {
+ if (!isCameraAttached()) {
+ Logger.w(TAG, CAMERA_NOT_ATTACHED);
+ return;
+ }
+ if (!mPinchToZoomEnabled) {
+ Logger.d(TAG, "Pinch to zoom disabled.");
+ return;
+ }
+ Logger.d(TAG, "Pinch to zoom with scale: " + pinchToZoomScale);
+
+ ZoomState zoomState = getZoomState().getValue();
+ if (zoomState == null) {
+ return;
+ }
+ float clampedRatio = zoomState.getZoomRatio() * speedUpZoomBy2X(pinchToZoomScale);
+ // Clamp the ratio with the zoom range.
+ clampedRatio = Math.min(Math.max(clampedRatio, zoomState.getMinZoomRatio()),
+ zoomState.getMaxZoomRatio());
+ setZoomRatio(clampedRatio);
+ }
+
+ private float speedUpZoomBy2X(float scaleFactor) {
+ if (scaleFactor > 1f) {
+ return 1.0f + (scaleFactor - 1.0f) * 2;
+ } else {
+ return 1.0f - (1.0f - scaleFactor) * 2;
+ }
+ }
+
+ /**
+ * 点击对焦
+ */
+ @SuppressLint("RestrictedApi")
+ @SuppressWarnings("FutureReturnValueIgnored")
+ public void onTapToFocus(MeteringPointFactory meteringPointFactory, float x, float y) {
+ if (!isCameraAttached()) {
+ Logger.w(TAG, CAMERA_NOT_ATTACHED);
+ return;
+ }
+ if (!mTapToFocusEnabled) {
+ Logger.d(TAG, "Tap to focus disabled. ");
+ return;
+ }
+ Logger.d(TAG, "Tap to focus started: start:" + x + ", " + y);
+ mTapToFocusState.postValue(TAP_TO_FOCUS_STARTED);
+ MeteringPoint afPoint = meteringPointFactory.createPoint(x, y, AF_SIZE);
+ MeteringPoint aePoint = meteringPointFactory.createPoint(x, y, AE_SIZE);
+ Logger.d(TAG, "Tap to focus started: after:" + afPoint.getX() + ", " + afPoint.getY());
+
+ FocusMeteringAction focusMeteringAction = new FocusMeteringAction
+ .Builder(afPoint, FocusMeteringAction.FLAG_AF)
+ .addPoint(aePoint, FocusMeteringAction.FLAG_AE)
+ .build();
+ Futures.addCallback(mCamera.getCameraControl().startFocusAndMetering(focusMeteringAction),
+ new FutureCallback() {
+
+ @Override
+ public void onSuccess(@Nullable FocusMeteringResult result) {
+ if (result == null) {
+ return;
+ }
+ Logger.d(TAG, "Tap to focus onSuccess: " + result.isFocusSuccessful());
+ mTapToFocusState.postValue(result.isFocusSuccessful()
+ ? TAP_TO_FOCUS_SUCCESSFUL : TAP_TO_FOCUS_UNSUCCESSFUL);
+ }
+
+ @Override
+ public void onFailure(Throwable t) {
+ if (t instanceof CameraControl.OperationCanceledException) {
+ Logger.d(TAG, "Tap-to-focus is canceled by new action.");
+ return;
+ }
+ Logger.d(TAG, "Tap to focus failed.", t);
+ mTapToFocusState.postValue(TAP_TO_FOCUS_FAILED);
+ }
+ }, CameraXExecutors.directExecutor());
+ }
+
+ @SuppressLint("RestrictedApi")
+ public ListenableFuture focus(MeteringPointFactory meteringPointFactory,
+ float x, float y, float ae_size, float af_size, long autoCancelTime /*ms*/) {
+ if (!isCameraAttached()) {
+ Logger.w(TAG, CAMERA_NOT_ATTACHED);
+ return Futures.immediateFailedFuture(new Throwable("camera not attach"));
+ }
+ Logger.d(TAG, "Silent focus started: start:" + x + ", " + y);
+ MeteringPoint afPoint = meteringPointFactory.createPoint(x, y, af_size);
+ MeteringPoint aePoint = meteringPointFactory.createPoint(x, y, ae_size);
+ Logger.d(TAG, "Silent focus started: after:" + afPoint.getX() + ", " + afPoint.getY());
+ FocusMeteringAction focusMeteringAction = new FocusMeteringAction
+ .Builder(afPoint, FocusMeteringAction.FLAG_AF)
+ .addPoint(aePoint, FocusMeteringAction.FLAG_AE)
+ .setAutoCancelDuration(autoCancelTime, TimeUnit.MILLISECONDS)
+ .build();
+ ListenableFuture focusFuture =
+ mCamera.getCameraControl().startFocusAndMetering(focusMeteringAction);
+ Futures.addCallback(focusFuture, new FutureCallback() {
+
+ @Override
+ public void onSuccess(@Nullable FocusMeteringResult result) {
+ if (result == null) {
+ return;
+ }
+ Logger.d(TAG, "Silent focus onSuccess: " + result.isFocusSuccessful());
+ }
+
+ @Override
+ public void onFailure(Throwable t) {
+ if (t instanceof CameraControl.OperationCanceledException) {
+ Logger.d(TAG, "Silent-focus is canceled by new action.");
+ return;
+ }
+ Logger.d(TAG, "Silent focus failed.", t);
+ }
+ }, CameraXExecutors.directExecutor());
+
+ return focusFuture;
+ }
+
+ /**
+ * Returns whether tap-to-focus is enabled.
+ *
+ * By default tap-to-focus is enabled.
+ *
+ * @return True if tap-to-focus is enabled.
+ */
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public boolean isTapToFocusEnabled() {
+ Threads.checkMainThread();
+ return mTapToFocusEnabled;
+ }
+
+
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public void setTapToFocusEnabled(boolean enabled) {
+ Threads.checkMainThread();
+ mTapToFocusEnabled = enabled;
+ }
+
+
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ @NonNull
+ public LiveData getTapToFocusState() {
+ Threads.checkMainThread();
+ return mTapToFocusState;
+ }
+
+ @SuppressLint("RestrictedApi")
+ @NonNull
+ @MainThread
+ public LiveData getZoomState() {
+ Threads.checkMainThread();
+ return mZoomState;
+ }
+
+ @SuppressLint("RestrictedApi")
+ @Nullable
+ @MainThread
+ public CameraInfo getCameraInfo() {
+ Threads.checkMainThread();
+ return mCamera == null ? null : mCamera.getCameraInfo();
+ }
+
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public LiveData> getCameraState() {
+ Threads.checkMainThread();
+ return mStateLiveData;
+ }
+
+
+ @SuppressLint("RestrictedApi")
+ @Nullable
+ @MainThread
+ public CameraControl getCameraControl() {
+ Threads.checkMainThread();
+ return mCamera == null ? null : mCamera.getCameraControl();
+ }
+
+ @SuppressLint("RestrictedApi")
+ @NonNull
+ @MainThread
+ public ListenableFuture setZoomRatio(float zoomRatio) {
+ Threads.checkMainThread();
+ if (!isCameraAttached()) {
+ Logger.w(TAG, CAMERA_NOT_ATTACHED);
+ return Futures.immediateFuture(null);
+ }
+ return mCamera.getCameraControl().setZoomRatio(zoomRatio);
+ }
+
+ @SuppressLint("RestrictedApi")
+ @NonNull
+ @MainThread
+ public ListenableFuture setLinearZoom(@FloatRange(from = 0f, to = 1f) float linearZoom) {
+ Threads.checkMainThread();
+ if (!isCameraAttached()) {
+ Logger.w(TAG, CAMERA_NOT_ATTACHED);
+ return Futures.immediateFuture(null);
+ }
+ return mCamera.getCameraControl().setLinearZoom(linearZoom);
+ }
+
+ @SuppressLint("RestrictedApi")
+ @NonNull
+ @MainThread
+ public LiveData getTorchState() {
+ Threads.checkMainThread();
+ return mTorchState;
+ }
+
+ @SuppressLint("RestrictedApi")
+ @NonNull
+ @MainThread
+ public LiveData getCameraInfoLiveData() {
+ return mCameraInfoLiveData;
+ }
+
+ public MutableLiveData getCameraControlLiveData() {
+ return mCameraControlLiveData;
+ }
+
+ @SuppressLint("RestrictedApi")
+ @NonNull
+ @MainThread
+ public ListenableFuture enableTorch(boolean torchEnabled) {
+ Threads.checkMainThread();
+ if (!isCameraAttached()) {
+ Logger.w(TAG, CAMERA_NOT_ATTACHED);
+ return Futures.immediateFuture(null);
+ }
+ return mCamera.getCameraControl().enableTorch(torchEnabled);
+ }
+
+ /**
+ * Binds use cases, gets a new {@link Camera} instance and tracks the state of the camera.
+ */
+ void startCameraAndTrackStates() {
+ startCameraAndTrackStates(null);
+ }
+
+ @SuppressLint("RestrictedApi")
+ void startCameraAndTrackStates(@Nullable Runnable restoreStateRunnable) {
+ try {
+ mCamera = startCamera();
+ } catch (Exception exception) {
+ if (restoreStateRunnable != null) {
+ restoreStateRunnable.run();
+ }
+ // Catches the core exception and throw a more readable one.
+ String errorMessage =
+ "The selected camera does not support the enabled use cases. Please "
+ + "disable use case and/or select a different camera. e.g. "
+ + "#setVideoCaptureEnabled(false)";
+ exception.printStackTrace();
+ //throw new IllegalStateException(errorMessage, exception);
+ }
+ if (!isCameraAttached()) {
+ Logger.d(TAG, CAMERA_NOT_ATTACHED);
+ return;
+ }
+ mCameraInfoLiveData.setValue(mCamera.getCameraInfo());
+ mCameraControlLiveData.setValue(mCamera.getCameraControl());
+ mZoomState.setSource(mCamera.getCameraInfo().getZoomState());
+ mTorchState.setSource(mCamera.getCameraInfo().getTorchState());
+
+ for (CameraInternal cameraInternal : mCamera.getCameraInternals()) {
+ if (mCamera.getCameraInfo() instanceof CameraInfoInternal && cameraInternal.getCameraInfo() instanceof CameraInfoInternal) {
+ String cameraId = ((CameraInfoInternal) mCamera.getCameraInfo()).getCameraId();
+ String compressCameraId = ((CameraInfoInternal) cameraInternal.getCameraInfo()).getCameraId();
+ if (cameraId.equals(compressCameraId)) {
+ mStateLiveData.setValue(cameraInternal.getCameraState());
+ break;
+ }
+ }
+ }
+ Log.i("CameraLifeManager", "init, PreviewSize: " + mPreview.getAttachedSurfaceResolution() + " " +
+ " CaptureSize:" + mImageCapture.getAttachedSurfaceResolution());
+
+ }
+
+ @SuppressLint({"RestrictedApi", "UnsafeExperimentalUsageError", "UnsafeOptInUsageError"})
+ @Nullable
+ @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+ protected UseCaseGroup createUseCaseGroup() {
+ if (!isCameraInitialized()) {
+ Logger.d(TAG, CAMERA_NOT_INITIALIZED);
+ return null;
+ }
+ if (!isPreviewViewAttached()) {
+ // Preview is required. Return early if preview Surface is not ready.
+ Logger.d(TAG, PREVIEW_VIEW_NOT_ATTACHED);
+ return null;
+ }
+
+ UseCaseGroup.Builder builder = new UseCaseGroup.Builder().addUseCase(mPreview);
+
+ if (isImageCaptureEnabled()) {
+ builder.addUseCase(mImageCapture);
+ } else {
+ mCameraProvider.unbind(mImageCapture);
+ }
+
+ if (isImageAnalysisEnabled()) {
+ builder.addUseCase(mImageAnalysis);
+ } else {
+ mCameraProvider.unbind(mImageAnalysis);
+ }
+
+ builder.setViewPort(mViewPort);
+ return builder.build();
+ }
+
+ @SuppressWarnings("WeakerAccess")
+ class DisplayRotationListener implements DisplayManager.DisplayListener {
+
+ @Override
+ public void onDisplayAdded(int displayId) {
+ }
+
+ @Override
+ public void onDisplayRemoved(int displayId) {
+ }
+
+ @SuppressLint({"WrongConstant", "UnsafeExperimentalUsageError", "UnsafeOptInUsageError"})
+ @Override
+ public void onDisplayChanged(int displayId) {
+
+ }
+ }
+
+ /**
+ * Nested class to avoid verification errors for methods introduced in Android 11 (API 30).
+ */
+ @RequiresApi(30)
+ private static class Api30Impl {
+
+ private Api30Impl() {
+ }
+
+ @NonNull
+ static Context createAttributionContext(@NonNull Context context,
+ @Nullable String attributeTag) {
+ return context.createAttributionContext(attributeTag);
+ }
+
+ @Nullable
+ static String getAttributionTag(@NonNull Context context) {
+ return context.getAttributionTag();
+ }
+ }
+
+ public static class OutputSize {
+
+ /**
+ * A value that represents the aspect ratio is not assigned.
+ */
+ public static final int UNASSIGNED_ASPECT_RATIO = -1;
+
+ /**
+ * Possible value for {@link #getAspectRatio()}
+ *
+ * @hide
+ */
+ @RestrictTo(RestrictTo.Scope.LIBRARY)
+ @Retention(RetentionPolicy.SOURCE)
+ @IntDef(value = {UNASSIGNED_ASPECT_RATIO, AspectRatio.RATIO_4_3, AspectRatio.RATIO_16_9})
+ public @interface OutputAspectRatio {
+ }
+
+ @OutputAspectRatio
+ private final int mAspectRatio;
+
+ @Nullable
+ private final Size mResolution;
+
+ /**
+ * Creates a {@link OutputSize} that is based on aspect ratio.
+ *
+ * @see Preview.Builder#setTargetAspectRatio(int)
+ * @see ImageAnalysis.Builder#setTargetAspectRatio(int)
+ */
+ @SuppressLint("RestrictedApi")
+ public OutputSize(@AspectRatio.Ratio int aspectRatio) {
+ Preconditions.checkArgument(aspectRatio != UNASSIGNED_ASPECT_RATIO);
+ mAspectRatio = aspectRatio;
+ mResolution = null;
+ }
+
+ /**
+ * Creates a {@link OutputSize} that is based on resolution.
+ *
+ * @see Preview.Builder#setTargetResolution(Size)
+ * @see ImageAnalysis.Builder#setTargetResolution(Size)
+ */
+ @SuppressLint("RestrictedApi")
+ public OutputSize(@NonNull Size resolution) {
+ Preconditions.checkNotNull(resolution);
+ mAspectRatio = UNASSIGNED_ASPECT_RATIO;
+ mResolution = resolution;
+ }
+
+ /**
+ * Gets the value of aspect ratio.
+ *
+ * @return {@link #UNASSIGNED_ASPECT_RATIO} if the size is not based on aspect ratio.
+ */
+ @OutputAspectRatio
+ public int getAspectRatio() {
+ return mAspectRatio;
+ }
+
+ /**
+ * Gets the value of resolution.
+ *
+ * @return null if the size is not based on resolution.
+ */
+ @Nullable
+ public Size getResolution() {
+ return mResolution;
+ }
+ }
+
+ public void setPreview(@NonNull Preview preview) {
+ this.mPreview = preview;
+ }
+
+ public void setImageCapture(@NonNull ImageCapture imageCapture) {
+ this.mImageCapture = imageCapture;
+ }
+
+ @NonNull
+ public Preview getPreview() {
+ return mPreview;
+ }
+
+ @NonNull
+ public ImageCapture getImageCapture() {
+ return mImageCapture;
+ }
+
+ @SuppressLint("RestrictedApi")
+ public int getCaptureTargetRotation() {
+ CameraInternal attachedCamera = mImageCapture.getCamera();
+ if (attachedCamera == null) {
+ return 90;
+ }
+
+ return attachedCamera.getCameraInfoInternal().getSensorRotationDegrees(
+ mImageCapture.getTargetRotation());
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/CameraXManager.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/CameraXManager.java
new file mode 100644
index 000000000..29c2176e8
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/CameraXManager.java
@@ -0,0 +1,569 @@
+package com.quark.quamera.camerax;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-25
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CaptureRequest;
+import android.os.Build;
+import android.os.Process;
+import android.util.LayoutDirection;
+import android.util.Log;
+import android.util.Size;
+import android.util.SizeF;
+
+import com.quark.quamera.camera.preview.ViewPort;
+import com.quark.quamera.camera.preview.ViewPorts;
+import com.quark.quamera.camera.session.SingleCaptureConfig;
+import com.quark.quamera.camerax.utils.FocalLengthInfo;
+import com.quark.quamera.camerax.utils.SingleThreadHandlerExecutor;
+import com.quark.quamera.render.view.CameraXPreviewView;
+import com.quark.quamera.util.CameraLogger;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import androidx.annotation.FloatRange;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.UiThread;
+import androidx.camera.camera2.impl.Camera2ImplConfig;
+import androidx.camera.camera2.internal.Camera2CameraCaptureResult;
+import androidx.camera.camera2.internal.Camera2CameraControlImpl;
+import androidx.camera.camera2.internal.Camera2CameraInfoImpl;
+import androidx.camera.core.CameraControl;
+import androidx.camera.core.CameraInfo;
+import androidx.camera.core.CameraSelector;
+import androidx.camera.core.ImageCapture;
+import androidx.camera.core.ImageCaptureException;
+import androidx.camera.core.ImageInfo;
+import androidx.camera.core.ImageProxy;
+import androidx.camera.core.Preview;
+import androidx.camera.core.ZoomState;
+import androidx.camera.core.impl.CameraCaptureCallback;
+import androidx.camera.core.impl.CameraCaptureResult;
+import androidx.camera.core.impl.CameraInfoInternal;
+import androidx.camera.core.impl.CameraInternal;
+import androidx.camera.core.impl.Observable;
+import androidx.camera.lifecycle.ProcessCameraProvider;
+import androidx.core.content.ContextCompat;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.LifecycleRegistry;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class CameraXManager implements LifecycleOwner, ICameraManager {
+
+ private LifecycleCameraController mCameraController;
+ private CameraXPreviewView mPreviewView;
+
+ private final ExecutorService mImageCaptureExecutorService;
+
+ private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
+
+ static final CameraSelector BACK_SELECTOR =
+ new CameraSelector.Builder().requireLensFacing(CameraSelector.LENS_FACING_BACK).build();
+ static final CameraSelector FRONT_SELECTOR =
+ new CameraSelector.Builder().requireLensFacing(
+ CameraSelector.LENS_FACING_FRONT).build();
+
+ private CameraSelector mCurrentCameraSelector = BACK_SELECTOR;
+
+ private final Context mContext;
+ private boolean useWideCamera;
+ private final SingleThreadHandlerExecutor mHandlerExecutor;
+
+ private final MutableLiveData mCameraStateLiveData = new MutableLiveData<>();
+ private CameraInfoInternal mCameraInfoInternal;
+
+ private Observable mLastObservable;
+
+ private boolean isLimitCaptureSize = true;
+ private Size maxCaptureSize;
+
+ public CameraXManager(@NonNull Context context) {
+ this.mContext = context;
+ mImageCaptureExecutorService = Executors.newSingleThreadExecutor();
+ mHandlerExecutor = new SingleThreadHandlerExecutor("camera_capture_result",
+ Process.THREAD_PRIORITY_BACKGROUND);
+ }
+
+ public void setCameraPreview(@NonNull CameraXPreviewView cameraPreview) {
+ mPreviewView = cameraPreview;
+ }
+
+ @Override
+ public void startCamera(Size previewSize, boolean useWideCamera, boolean needBindLifecycle) {
+ startCamera(previewSize, useWideCamera, needBindLifecycle, true, null);
+ }
+
+ @SuppressLint("RestrictedApi")
+ public void startCamera(Size previewSize, boolean useWideCamera, boolean needBindLifecycle, boolean isLimitCaptureSize, Size maxCaptureSize) {
+ this.useWideCamera = useWideCamera;
+ this.isLimitCaptureSize = isLimitCaptureSize;
+ this.maxCaptureSize = maxCaptureSize;
+
+ if (mLastObservable != null) {
+ mLastObservable.removeObserver(observer);
+ }
+ if (mCameraController != null) {
+ mCameraController.unbind();
+ }
+
+ mCameraController = new LifecycleCameraController(mContext, previewSize, isLimitCaptureSize, maxCaptureSize, new OnCameraProviderListener() {
+ @Override
+ public void onProcessCameraProvider(ProcessCameraProvider provider) {
+ mCameraController.initCameraSelector(mCurrentCameraSelector);
+ }
+ });
+ mCameraController.getCameraInfoLiveData().observe(this, this::onCameraInfoObserved);
+ if (needBindLifecycle) {
+ mCameraController.bindToLifecycle(this);
+ }
+ /*
+ * 内部会将CameraPreviewView的mSurfaceProvider对象传给Preview的setSurfaceProvider方法
+ * 然后再调用SurfaceRequest的providerSurface方法将Surface传入
+ */
+ mPreviewView.setCameraController(mCameraController);
+
+ mCameraController.getCameraState().observeForever(stateObservable -> {
+ this.mLastObservable = stateObservable;
+ stateObservable.addObserver(ContextCompat.getMainExecutor(mContext), observer);
+ });
+ }
+
+ private CameraInternal.State mPreState;
+
+ private final Observable.Observer observer = new Observable.Observer() {
+ @Override
+ public void onNewData(@Nullable CameraInternal.State value) {
+ if (value == CameraInternal.State.OPEN) {
+ mCameraStateLiveData.setValue(1);
+ } else if (value == CameraInternal.State.CLOSED) {
+ // 正在关闭相机，下一帧的时候释放Surface
+ if (CameraInternal.State.CLOSING == mPreState) {
+ Log.i("CameraXManager", "releaseSurface: ");
+ mPreviewView.post(() -> mPreviewView.releaseSurface());
+ }
+ }
+ mPreState = value;
+ }
+
+ @Override
+ public void onError(@NonNull Throwable t) {
+
+ }
+ };
+
+
+ @UiThread
+ public void takePicture(ImageCapture.OutputFileOptions outputFileOptions,
+ @NonNull ImageCapture.OnImageSavedCallback imageSavedCallback) {
+ if (mCameraController == null) {
+ return;
+ }
+ // 添加viewPortCropRect对象，拍照裁剪的Rect
+ mCameraController.takePicture(outputFileOptions, mImageCaptureExecutorService, imageSavedCallback, getViewPortRect());
+ }
+
+ /**
+ * 拍照返回原始数据，没有对数据进行裁剪和旋转操作
+ */
+ @UiThread
+ @SuppressLint("RestrictedApi")
+ public void takePictureOriginalData(SingleCaptureConfig singleCaptureConfig, com.quark.quamera.camera.session.ImageCapture.OnImageCapturedCallback capturedCallback) {
+ if (mCameraController == null) {
+ return;
+ }
+ Rect viewPortRect;
+ if (singleCaptureConfig.getCameraShowRect() != null) {
+ RectF rectF = singleCaptureConfig.getCameraShowRect();
+ viewPortRect = new Rect((int) rectF.left, (int) rectF.top, (int) rectF.right, (int) rectF.bottom);
+ } else {
+ viewPortRect = getViewPortRect();
+ }
+ if (viewPortRect != null) {
+ mCameraController.getImageCapture().setViewPortCropRect(viewPortRect);
+ }
+ mCameraController.takePicture(mImageCaptureExecutorService, new ImageCapture.OnImageCapturedCallback() {
+ @Override
+ public void onCaptureSuccess(@NonNull ImageProxy image) {
+ super.onCaptureSuccess(image);
+ try {
+ ImageProxy.PlaneProxy[] planes = image.getPlanes();
+ if (planes.length > 0 && capturedCallback != null) {
+ ByteBuffer buffer = planes[0].getBuffer();
+ // 原始数据
+ byte[] bytes = new byte[buffer.capacity()];
+ buffer.get(bytes);
+
+ Size size = new Size(Math.max(image.getHeight(), image.getWidth()), Math.min(image.getWidth(), image.getHeight()));
+ ImageInfo imageInfo = image.getImageInfo();
+ // 原始数据回调给外层处理
+ capturedCallback.onCaptureSuccess(bytes, size, image.getCropRect(), ExifRotationHelper.isHuaweiNova3i() ?
+ mCameraController.getCaptureTargetRotation() : imageInfo.getRotationDegrees());
+ }
+ } finally {
+ image.close();
+ }
+ }
+
+ @Override
+ public void onError(@NonNull ImageCaptureException exception) {
+ super.onError(exception);
+ if (capturedCallback != null) {
+ capturedCallback.onError(exception);
+ }
+ }
+ });
+ }
+
+ private com.quark.quamera.camera.session.CameraSelector.CameraLenFacing mPreCameraLenFacing =
+ com.quark.quamera.camera.session.CameraSelector.CameraLenFacing.LEN_FACING_BACK;
+
+ /**
+ * 转换摄像头
+ *
+ * @param cameraLenFacing CameraLenFacing
+ */
+ @UiThread
+ @SuppressLint("RestrictedApi")
+ public void switchCamera(com.quark.quamera.camera.session.CameraSelector.CameraLenFacing cameraLenFacing, Size previewSize) {
+ if (cameraLenFacing == null) {
+ if (mCurrentCameraSelector == FRONT_SELECTOR) {
+ mCurrentCameraSelector = BACK_SELECTOR;
+ } else {
+ mCurrentCameraSelector = FRONT_SELECTOR;
+ }
+ } else {
+ if (mPreCameraLenFacing != null && mPreCameraLenFacing == cameraLenFacing) {
+ return;
+ }
+ if (cameraLenFacing == com.quark.quamera.camera.session.CameraSelector.CameraLenFacing.LEN_FACING_FONT) {
+ mCurrentCameraSelector = FRONT_SELECTOR;
+ } else {
+ mCurrentCameraSelector = BACK_SELECTOR;
+ }
+ mPreCameraLenFacing = cameraLenFacing;
+ }
+ startCamera(previewSize, useWideCamera, true, isLimitCaptureSize, maxCaptureSize);
+ }
+
+ @SuppressLint("RestrictedApi")
+ public void enableFlash(boolean enable) {
+ if (mCameraController == null || !mCameraController.isCameraAttached()) {
+ return;
+ }
+ CameraInfo cameraInfo = getCameraInfo();
+ CameraControl cameraControl = getCameraControl();
+ if (cameraInfo == null || cameraControl == null) {
+ return;
+ }
+ cameraControl.enableTorch(enable);
+ }
+
+ public void setScaleType(@ViewPort.ScaleType int scaleType) {
+ mPreviewView.setScaleType(scaleType);
+ }
+
+ public void onWindowCreate() {
+ mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
+ }
+
+ public void onWindowActive() {
+ mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
+ mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
+
+ if (mCameraController != null) {
+ mCameraController.bindToLifecycle(this);
+ }
+ }
+
+ public void onWindowInactive() {
+ mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
+ mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
+
+ if (mCameraController != null) {
+ mCameraController.unbind();
+ }
+ }
+
+ public void onWindowResume() {
+ mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
+ }
+
+ public void onWindowPause() {
+ mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
+ }
+
+ @SuppressLint("RestrictedApi")
+ public void onWindowDestroy() {
+ onWindowInactive();
+ mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
+ if (mImageCaptureExecutorService != null) {
+ mImageCaptureExecutorService.shutdown();
+ }
+ if (mCameraInfoInternal != null) {
+ mCameraInfoInternal.removeSessionCaptureCallback(callback);
+ }
+ if (mHandlerExecutor != null) {
+ mHandlerExecutor.shutdown();
+ }
+ if (mCameraController != null) {
+ mCameraController.unbind();
+ }
+ if (mLastObservable != null) {
+ mLastObservable.removeObserver(observer);
+ }
+ }
+
+ @Nullable
+ public CameraControl getCameraControl() {
+ return mCameraController != null ? mCameraController.getCameraControl() : null;
+ }
+
+ @Nullable
+ public CameraInfo getCameraInfo() {
+ return mCameraController != null ? mCameraController.getCameraInfo() : null;
+ }
+
+ @Nullable
+ public LiveData getCameraInfoLiveData() {
+ return mCameraController != null ? mCameraController.getCameraInfoLiveData() : null;
+ }
+
+ public LiveData getCameraState() {
+ return mCameraStateLiveData;
+ }
+
+ public ImageCapture getImageCapture() {
+ return mCameraController != null ? mCameraController.getImageCapture() : null;
+ }
+
+
+ public Preview getPreview() {
+ return mCameraController != null ? mCameraController.getPreview() : null;
+ }
+
+ public void setLinearZoom(@FloatRange(from = 0f, to = 1f) float linearZoom) {
+ if (mCameraController == null) {
+ return;
+ }
+ mCameraController.setLinearZoom(linearZoom);
+ }
+
+ public void setZoomRatio(float zoomRatio) {
+ if (mCameraController == null) {
+ return;
+ }
+ mCameraController.setZoomRatio(zoomRatio);
+ }
+
+ @Nullable
+ public LiveData getZoomState() {
+ if (mCameraController == null) {
+ return null;
+ }
+ return mCameraController.getZoomState();
+ }
+
+ @Nullable
+ public LiveData getTapToFocusState() {
+ if (mCameraController == null) {
+ return null;
+ }
+ return mCameraController.getTapToFocusState();
+ }
+
+ @NonNull
+ @Override
+ public Lifecycle getLifecycle() {
+ return mLifecycleRegistry;
+ }
+
+ @SuppressLint("RestrictedApi")
+ private Rect getViewPortRect() {
+ CameraInfo cameraInfo = getCameraInfo();
+ Size size = getImageCapture().getAttachedSurfaceResolution();
+
+ if (cameraInfo instanceof Camera2CameraInfoImpl && size != null) {
+ Camera2CameraInfoImpl infoImpl = (Camera2CameraInfoImpl) cameraInfo;
+ CameraCharacteristics characteristics = infoImpl.getCameraCharacteristicsCompat().toCameraCharacteristics();
+
+ boolean isFrontCamera =
+ characteristics.get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_FRONT;
+ Rect sensorRect = characteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
+ Integer sensorOrientation =
+ characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
+ int rotation = sensorOrientation != null ? sensorOrientation : 0;
+ return ViewPorts.calculateViewPortRect(
+ sensorRect,
+ isFrontCamera,
+ mPreviewView.getAspectRatio(),
+ rotation,
+ ViewPort.FILL_CENTER,
+ LayoutDirection.LTR,
+ size
+ );
+ }
+ return null;
+ }
+
+ @SuppressLint("RestrictedApi")
+ private void onCameraInfoObserved(CameraInfo cameraInfo) {
+ // 使用广角镜头的逻辑
+ onUseWipeCameraInfo(cameraInfo);
+
+ // 添加每一帧的回调
+ addSessionCaptureCallback(cameraInfo);
+
+ // 对焦状态
+ onCameraCaptureResulted(cameraInfo);
+
+ //人脸拍摄
+ }
+
+ private final CameraCaptureCallback callback = new CameraCaptureCallback() {
+ @SuppressLint("RestrictedApi")
+ @Override
+ public void onCaptureCompleted(@NonNull CameraCaptureResult cameraCaptureResult) {
+ super.onCaptureCompleted(cameraCaptureResult);
+
+ // 获取CaptureResult对象。用于每一帧主动释放内存，解决内存峰值高的问题
+ if (mPreviewView != null && cameraCaptureResult instanceof Camera2CameraCaptureResult) {
+ Camera2CameraCaptureResult camera2CameraCaptureResult = (Camera2CameraCaptureResult) cameraCaptureResult;
+
+ mPreviewView.cacheCaptureResult(camera2CameraCaptureResult);
+ }
+ }
+ };
+
+ @SuppressLint("RestrictedApi")
+ private void addSessionCaptureCallback(CameraInfo cameraInfo) {
+ if (cameraInfo instanceof CameraInfoInternal) {
+
+ mCameraInfoInternal = ((CameraInfoInternal) cameraInfo);
+ mCameraInfoInternal.addSessionCaptureCallback(mHandlerExecutor, callback);
+ }
+ }
+
+ private final List mFocalLengths = new ArrayList<>();
+ // 最大的水平广角 超过认为是超广角 可能会导致变形
+ private static final int MAX_ANGLE = 90;
+
+ private void onUseWipeCameraInfo(CameraInfo cameraInfo) {
+ mFocalLengths.clear();
+ if (cameraInfo instanceof Camera2CameraInfoImpl) {
+ @SuppressLint("RestrictedApi") CameraCharacteristics cc = ((Camera2CameraInfoImpl) cameraInfo)
+ .getCameraCharacteristicsCompat().toCameraCharacteristics();
+ SizeF size = cc.get(CameraCharacteristics.SENSOR_INFO_PHYSICAL_SIZE);
+ float[] focalLens = cc.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS);
+
+ double width = size.getWidth();
+ double height = size.getHeight();
+
+ boolean firstOne = true;
+ for (float focalLength : focalLens) {
+ FocalLengthInfo lengthInfo = new FocalLengthInfo();
+ lengthInfo.horizontalAngle = (2 * Math.atan(width / (focalLength * 2)));
+ lengthInfo.verticalAngle = (2 * Math.atan(height / (focalLength * 2)));
+ lengthInfo.focalLength = focalLength;
+ //一般情况下，第一个焦距信息为默认焦距
+ lengthInfo.isDefaultFocal = firstOne;
+ firstOne = false;
+ mFocalLengths.add(lengthInfo);
+ }
+ }
+ Collections.sort(mFocalLengths);
+
+ StringBuilder sb = new StringBuilder("\n");
+ for (FocalLengthInfo minFL : mFocalLengths) {
+ sb.append(String.format(Locale.CHINA, "camera min_fl: %.2f ; max_h_angle : %.2f ",
+ (minFL != null ? minFL.focalLength : -1),
+ (minFL != null ? minFL.horizontalAngle * 180 / Math.PI : -1)))
+ .append("\n").append(" isDefault:").append((minFL != null && minFL.isDefaultFocal));
+ }
+ CameraLogger.i("CameraLifeManager", "print match camera list\n %s", sb);
+
+ mCameraController.getCameraControlLiveData().observe(this, this::useWideCameraInfo);
+ }
+
+ /**
+ * 优先使用逻辑广角镜头
+ */
+ @SuppressLint({"RestrictedApi", "UnsafeOptInUsageError", "UnsafeExperimentalUsageError"})
+ private void useWideCameraInfo(CameraControl cameraControl) {
+ FocalLengthInfo bestFocalInfo;
+ if (useWideCamera && (bestFocalInfo = getBestFocalInfo()) != null) {
+ float focalLength = bestFocalInfo.focalLength;
+ if (cameraControl instanceof Camera2CameraControlImpl) {
+ Camera2ImplConfig captureRequestOption = new Camera2ImplConfig.Builder()
+ .setCaptureRequestOption(CaptureRequest.LENS_FOCAL_LENGTH, focalLength).build();
+
+ Camera2CameraControlImpl controlImpl = (Camera2CameraControlImpl) cameraControl;
+ controlImpl.getCamera2CameraControl().
+ addCaptureRequestOptions(captureRequestOption);
+ }
+ }
+ }
+
+ /**
+ * 返回最佳的焦距信息
+ */
+ private FocalLengthInfo getBestFocalInfo() {
+ FocalLengthInfo defaultInfo = null;
+ for (FocalLengthInfo info : mFocalLengths) {
+ if (info.isDefaultFocal) {
+ defaultInfo = info;
+ }
+ double angle = info.horizontalAngle * 180 / Math.PI;
+ if (angle <= MAX_ANGLE) {
+ return info;
+ }
+ }
+ // 如果所有焦距对应角度都大于90 选择默认焦距
+ return defaultInfo;
+ }
+
+ private OnCaptureResultListener mCaptureResultListener;
+
+ public void setOnCaptureResultListener(OnCaptureResultListener listener) {
+ this.mCaptureResultListener = listener;
+ }
+
+ /**
+ * 获取每一帧的对焦状态
+ */
+ @SuppressLint("RestrictedApi")
+ private void onCameraCaptureResulted(CameraInfo cameraInfo) {
+ if (cameraInfo instanceof CameraInfoInternal && mCaptureResultListener != null) {
+ CameraInfoInternal infoInternal = (CameraInfoInternal) cameraInfo;
+ infoInternal.addSessionCaptureCallback(mImageCaptureExecutorService, new CameraCaptureCallback() {
+ @Override
+ public void onCaptureCompleted(@NonNull CameraCaptureResult cameraCaptureResult) {
+ if (mCaptureResultListener != null) {
+ mCaptureResultListener.onCaptureResulted(cameraCaptureResult);
+ }
+ }
+ });
+ }
+ }
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/ExifRotationHelper.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/ExifRotationHelper.java
new file mode 100644
index 000000000..15d025dc3
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/ExifRotationHelper.java
@@ -0,0 +1,59 @@
+package com.quark.quamera.camerax;
+
+import android.annotation.SuppressLint;
+import android.media.ExifInterface;
+import android.os.Build;
+
+import java.io.File;
+import java.io.IOException;
+
+import androidx.camera.core.impl.utils.Exif;
+import androidx.camera.core.internal.compat.workaround.ExifRotationAvailability;
+
+/**
+ * 华为一些特殊机型无法正确处理获取旋转信息，exif的旋转方向值错误。对于这些设备，我们应该根据最终输出图像的目标旋转设置计算旋转值
+ *
+ * @author : yushan.lj@alibaba-inc.com
+ * @date : 2022/2/25
+ */
+public class ExifRotationHelper {
+
+
+ @SuppressLint("RestrictedApi")
+ public static void updateExitRotate(File file, int rotate) {
+ if (isNeedUpdateExitInfo()) {
+ try {
+ Exif exif = Exif.createFromFile(file);
+
+ int orientation = 0;
+ switch (rotate) {
+ case 90:
+ orientation = ExifInterface.ORIENTATION_ROTATE_90;
+ break;
+ case 180:
+ orientation = ExifInterface.ORIENTATION_ROTATE_180;
+ break;
+ case 270:
+ orientation = ExifInterface.ORIENTATION_ROTATE_270;
+ break;
+ }
+
+ exif.setOrientation(orientation);
+ exif.save();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+
+ }
+ }
+
+ @SuppressLint("RestrictedApi")
+ public static boolean isNeedUpdateExitInfo() {
+ return !new ExifRotationAvailability().isRotationOptionSupported() || isHuaweiNova3i();
+ }
+
+ public static boolean isHuaweiNova3i() {
+ return "HUAWEI".equalsIgnoreCase(Build.BRAND) && "INE-TL00".equalsIgnoreCase(Build.MODEL);
+ }
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/FaceMode.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/FaceMode.java
new file mode 100644
index 000000000..7d3d34de1
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/FaceMode.java
@@ -0,0 +1,121 @@
+package com.quark.quamera.camerax;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/11/15
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.annotation.SuppressLint;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CaptureRequest;
+import android.os.Build;
+import android.util.Range;
+import android.util.Rational;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+import androidx.annotation.RequiresApi;
+import androidx.camera.camera2.impl.Camera2ImplConfig;
+import androidx.camera.camera2.internal.Camera2CameraControlImpl;
+import androidx.camera.camera2.internal.Camera2CameraInfoImpl;
+import androidx.camera.core.CameraControl;
+import androidx.camera.core.CameraSelector;
+
+/**
+ *
+ // private FaceMode mFaceMode = new FaceMode();
+
+ // @SuppressLint("RestrictedApi")
+ // private void checkFaceModeCharacteristics(CameraInfo cameraInfo) {
+ // if (!(cameraInfo instanceof Camera2CameraInfoImpl)) {
+ // return;
+ // }
+ // String id = ((Camera2CameraInfoImpl) cameraInfo).getCameraId();
+ //
+ // mFaceMode.checkCamera(id, (Camera2CameraInfoImpl) cameraInfo);
+ // mCameraController.getCameraControlLiveData().observe(this, cameraControl -> mFaceMode.fillCameraCharacteristics(id, cameraControl));
+ // }
+
+ * 暂时没用，设计目的是在不同mode下调节相机参数
+ */
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+class FaceMode {
+
+ private static class FaceCameraConfig {
+ Range aeRange;
+ Rational aeStep;
+
+
+ boolean isValid() {
+ return aeRange != null && aeStep != null;
+ }
+ }
+
+ private ConcurrentHashMap mCameraFaceConfig = new ConcurrentHashMap<>();
+
+
+ @SuppressLint("RestrictedApi")
+ public boolean checkCamera(String id, Camera2CameraInfoImpl cameraInfo) {
+ if ((cameraInfo == null)) {
+ return false;
+ }
+
+
+ if (mCameraFaceConfig.containsKey(id)) {
+ return true;
+ }
+
+ //TODO 确认是否需要用这个方式判断前后摄象机(目前写死只有前置，后续可以作为一个参数填写进来)
+ if (cameraInfo.getLensFacing() == null ||
+ cameraInfo.getLensFacing() != CameraSelector.LENS_FACING_FRONT) {
+ return false;
+ }
+
+ FaceCameraConfig config = new FaceCameraConfig();
+
+ CameraCharacteristics cc = (cameraInfo)
+ .getCameraCharacteristicsCompat().toCameraCharacteristics();
+ Range range = cc.get(CameraCharacteristics.CONTROL_AE_COMPENSATION_RANGE);
+ Rational aeStep = cc.get(CameraCharacteristics.CONTROL_AE_COMPENSATION_STEP);
+ if (range.getUpper() > 0) {
+ config.aeRange = range;
+ config.aeStep = aeStep;
+ }
+
+ mCameraFaceConfig.put(cameraInfo.getCameraId(), config);
+
+ return true;
+ }
+
+ /**
+ * 优先使用逻辑广角镜头
+ */
+ @SuppressLint({"RestrictedApi", "UnsafeOptInUsageError", "UnsafeExperimentalUsageError"})
+ public void fillCameraCharacteristics(String cameraId, CameraControl cameraControl) {
+ if (!mCameraFaceConfig.containsKey(cameraId)) {
+ return;
+ }
+ FaceCameraConfig config = mCameraFaceConfig.get(cameraId);
+
+ if (!config.isValid()) {
+ return;
+ }
+
+ if (cameraControl instanceof Camera2CameraControlImpl) {
+ int stepValue = (int) (1f / config.aeStep.floatValue());
+ //白平衡增加一个亮度
+ if (!config.aeRange.contains(stepValue)) {
+ return;
+ }
+
+ Camera2ImplConfig captureRequestOption = new Camera2ImplConfig.Builder()
+ .setCaptureRequestOption(CaptureRequest.CONTROL_AE_EXPOSURE_COMPENSATION, stepValue).build();
+ Camera2CameraControlImpl controlImpl = (Camera2CameraControlImpl) cameraControl;
+ controlImpl.getCamera2CameraControl().
+ addCaptureRequestOptions(captureRequestOption);
+ }
+ }
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/ICameraManager.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/ICameraManager.java
new file mode 100644
index 000000000..07d019434
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/ICameraManager.java
@@ -0,0 +1,37 @@
+package com.quark.quamera.camerax;
+
+import android.util.Size;
+
+import com.quark.quamera.camera.session.SingleCaptureConfig;
+import com.quark.quamera.render.view.BasePreviewView;
+
+import androidx.annotation.NonNull;
+
+/**
+ * @author : yushan.lj@alibaba-inc.com
+ * @date : 2021/10/17
+ */
+public interface ICameraManager {
+
+ void setCameraPreview(@NonNull T cameraPreview);
+
+ void onWindowCreate();
+
+ void onWindowActive();
+
+ void onWindowInactive();
+
+ void onWindowDestroy();
+
+ void startCamera(Size previewSize, boolean useWideCamera, boolean needBindLifecycle);
+
+ void startCamera(Size previewSize, boolean useWideCamera, boolean needBindLifecycle, boolean isLimitCaptureSize, Size maxCaptureSize);
+
+ void switchCamera(com.quark.quamera.camera.session.CameraSelector.CameraLenFacing cameraLenFacing, Size previewSize);
+
+ void takePictureOriginalData(SingleCaptureConfig singleCaptureConfig, com.quark.quamera.camera.session.ImageCapture.OnImageCapturedCallback capturedCallback);
+
+ void enableFlash(boolean enable);
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/LifecycleCameraController.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/LifecycleCameraController.java
new file mode 100644
index 000000000..967ffe4a8
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/LifecycleCameraController.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camerax;
+
+import android.Manifest;
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.os.Build;
+import android.util.Log;
+import android.util.Size;
+
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RequiresPermission;
+import androidx.camera.core.Camera;
+import androidx.camera.core.UseCaseGroup;
+import androidx.camera.core.impl.utils.Threads;
+import androidx.camera.lifecycle.ProcessCameraProvider;
+import androidx.lifecycle.LifecycleOwner;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+final class LifecycleCameraController extends CameraController {
+
+ private static final String TAG = "CamLifecycleController";
+
+ @Nullable
+ private LifecycleOwner mLifecycleOwner;
+
+ public LifecycleCameraController(@NonNull Context context, Size previewSize) {
+ super(context, previewSize);
+ }
+
+ public LifecycleCameraController(@NonNull Context context, Size previewSize, boolean isLimitCaptureSize, Size maxCaptureSize, OnCameraProviderListener listener) {
+ super(context, previewSize, isLimitCaptureSize, maxCaptureSize, listener);
+ }
+
+ @SuppressLint({"MissingPermission", "RestrictedApi"})
+ @MainThread
+ public void bindToLifecycle(@NonNull LifecycleOwner lifecycleOwner) {
+ Threads.checkMainThread();
+ mLifecycleOwner = lifecycleOwner;
+ startCameraAndTrackStates();
+ }
+
+ /**
+ * Clears the previously set {@link LifecycleOwner} and stops the camera.
+ *
+ * @see ProcessCameraProvider#unbindAll
+ */
+ @SuppressLint("RestrictedApi")
+ @MainThread
+ public void unbind() {
+ Threads.checkMainThread();
+ mLifecycleOwner = null;
+ mCamera = null;
+ if (mCameraProvider != null) {
+ mCameraProvider.unbindAll();
+ }
+ }
+
+ /**
+ * Unbind and rebind all use cases to {@link LifecycleOwner}.
+ *
+ * @return null if failed to start camera.
+ */
+ @SuppressLint({"UnsafeExperimentalUsageError", "UnsafeOptInUsageError", "RestrictedApi"})
+ @RequiresPermission(Manifest.permission.CAMERA)
+ @Override
+ @Nullable
+ Camera startCamera() {
+ if (mLifecycleOwner == null) {
+ Log.d(TAG, "Lifecycle is not set.");
+ return null;
+ }
+ if (mCameraProvider == null) {
+ Log.d(TAG, "CameraProvider is not ready.");
+ return null;
+ }
+
+ UseCaseGroup useCaseGroup = createUseCaseGroup();
+ if (useCaseGroup == null) {
+ // Use cases can't be created.
+ return null;
+ }
+
+ return mCameraProvider.bindToLifecycle(mLifecycleOwner, mCameraSelector, useCaseGroup);
+ }
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/OnCameraProviderListener.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/OnCameraProviderListener.java
new file mode 100644
index 000000000..175b112dd
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/OnCameraProviderListener.java
@@ -0,0 +1,20 @@
+package com.quark.quamera.camerax;
+
+import androidx.camera.lifecycle.ProcessCameraProvider;
+
+/**
+ * 在CameraController中Camera创建完成后的回调接口
+ *
+ * @author : liujian
+ * @date : 2021/7/30
+ */
+public interface OnCameraProviderListener {
+
+ /**
+ * ProcessCameraProvider对象创建完成后的回调方法
+ *
+ * @param provider ProcessCameraProvider
+ */
+ void onProcessCameraProvider(ProcessCameraProvider provider);
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/OnCaptureResultListener.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/OnCaptureResultListener.java
new file mode 100644
index 000000000..fd1a43102
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/OnCaptureResultListener.java
@@ -0,0 +1,11 @@
+package com.quark.quamera.camerax;
+
+import androidx.camera.core.impl.CameraCaptureResult;
+
+/**
+ * @author : yushan.lj@alibaba-inc.com
+ * @date : 2022/3/14
+ */
+public interface OnCaptureResultListener {
+ void onCaptureResulted(CameraCaptureResult cameraCaptureResult);
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/CameraViewTouchManager.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/CameraViewTouchManager.java
new file mode 100644
index 000000000..866a3aae3
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/CameraViewTouchManager.java
@@ -0,0 +1,234 @@
+package com.quark.quamera.camerax.controller;
+
+import android.annotation.SuppressLint;
+import android.graphics.PointF;
+import android.os.Build;
+import android.util.Log;
+import android.util.Rational;
+import android.util.Size;
+import android.view.Display;
+import android.view.MotionEvent;
+import android.view.ScaleGestureDetector;
+import android.view.ViewConfiguration;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.quark.quamera.camerax.CameraController;
+import com.quark.quamera.render.view.CameraXPreviewView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.UiThread;
+import androidx.camera.core.FocusMeteringResult;
+import androidx.camera.core.SurfaceRequest;
+import androidx.camera.core.ViewPort;
+import androidx.camera.core.ZoomState;
+import androidx.camera.core.impl.ImageOutputConfig;
+import androidx.camera.core.impl.utils.futures.Futures;
+
+/**
+ * @author : liujian
+ * @date : 2021/7/28
+ */
+public class CameraViewTouchManager implements ICameraViewTouchManager {
+ private static final String TAG = "CameraViewTouchListener";
+
+ private final CameraXPreviewView mTouchView;
+ private final ScaleGestureDetector mScaleGestureDetector;
+
+ @NonNull
+ final PreviewTransformation mPreviewTransform = new PreviewTransformation();
+
+ @NonNull
+ PreviewViewMeteringPointFactory mPreviewViewMeteringPointFactory =
+ new PreviewViewMeteringPointFactory(mPreviewTransform);
+
+ @Nullable
+ private MotionEvent mTouchUpEvent;
+
+ private OnGestureDetectorListener mGestureListener;
+ private CameraController mCameraController;
+
+ class PinchToZoomOnScaleGestureListener extends
+ ScaleGestureDetector.SimpleOnScaleGestureListener {
+ @Override
+ public boolean onScale(ScaleGestureDetector detector) {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+ return false;
+ }
+ if (mCameraController != null) {
+ // 手势缩放
+ mCameraController.onPinchToZoom(detector.getScaleFactor());
+
+ ZoomState value = mCameraController.getZoomState().getValue();
+ if (mGestureListener != null && value != null) {
+ mGestureListener.onPinchToZoom(value.getZoomRatio(), value.getMaxZoomRatio(), value.getMinZoomRatio());
+ }
+ }
+ return true;
+ }
+ }
+
+ public CameraViewTouchManager(@NonNull CameraXPreviewView touchView) {
+ this.mTouchView = touchView;
+
+ mScaleGestureDetector = new ScaleGestureDetector(
+ touchView.getContext(), new PinchToZoomOnScaleGestureListener());
+ }
+
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ @UiThread
+ @Override
+ public void setCameraController(@Nullable CameraController cameraController) {
+ if (mCameraController != null && mCameraController != cameraController) {
+ mCameraController.clearPreviewSurface();
+ }
+ mCameraController = cameraController;
+ attachToControllerIfReady();
+ }
+
+ @Override
+ public void setOnGestureDetectorListener(OnGestureDetectorListener listener) {
+ this.mGestureListener = listener;
+ }
+
+ @SuppressLint("RestrictedApi")
+
+ @Override
+ public ListenableFuture autoFocus(float x, float y, float size, long autoCancelTimes) {
+ if (mCameraController == null) {
+ return Futures.immediateFailedFuture(new Throwable("camera controller not init"));
+ }
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+ return mCameraController.focus(mPreviewViewMeteringPointFactory, x, y, size, size, autoCancelTimes);
+ } else {
+ return Futures.immediateFailedFuture(new Throwable("api is lower than Build.VERSION_CODES.LOLLIPOP"));
+ }
+ }
+
+ @UiThread
+ @Nullable
+ public ViewPort getViewPort() {
+ if (mTouchView.getDisplay() == null) {
+ return null;
+ }
+ return getViewPort(mTouchView.getDisplay().getRotation());
+ }
+
+
+ @UiThread
+ @SuppressLint({"WrongConstant", "UnsafeExperimentalUsageError", "UnsafeOptInUsageError"})
+ @Nullable
+ public ViewPort getViewPort(@ImageOutputConfig.RotationValue int targetRotation) {
+ if (mTouchView.getWidth() == 0 || mTouchView.getHeight() == 0) {
+ return null;
+ }
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+ return null;
+ }
+ return new ViewPort.Builder(new Rational(mTouchView.getWidth(), mTouchView.getHeight()), targetRotation)
+ .setScaleType(getViewPortScaleType())
+ .setLayoutDirection(mTouchView.getLayoutDirection())
+ .build();
+ }
+
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ if (mCameraController == null) {
+ return false;
+ }
+ boolean isSingleTouch = event.getPointerCount() == 1;
+ boolean isUpEvent = event.getAction() == MotionEvent.ACTION_UP;
+ boolean notALongPress = event.getEventTime() - event.getDownTime()
+ < ViewConfiguration.getLongPressTimeout();
+ if (isSingleTouch && isUpEvent && notALongPress) {
+ mTouchUpEvent = event;
+ performClick();
+
+ return true;
+ }
+ return mScaleGestureDetector.onTouchEvent(event);
+ }
+
+ @Override
+ public void performClick() {
+ if (mCameraController != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+ float x = mTouchUpEvent != null ? mTouchUpEvent.getX() : mTouchView.getWidth() / 2f;
+ float y = mTouchUpEvent != null ? mTouchUpEvent.getY() : mTouchView.getHeight() / 2f;
+
+ float[] marginPercentage = mTouchView.getRender().getMarginPercentage();
+
+ float viewHeight = mTouchView.getHeight();
+ float topY = viewHeight * marginPercentage[1];
+ float bottomY = viewHeight * (1 - marginPercentage[3]);
+ if (viewHeight == 0 || (y >= topY && y <= bottomY)) {
+ // 点击对焦
+ mCameraController.onTapToFocus(mPreviewViewMeteringPointFactory, x, y);
+
+ if (mGestureListener != null) {
+ mGestureListener.onClickFocused(x, y);
+ }
+ }
+ }
+ mTouchUpEvent = null;
+ }
+
+ @Override
+ public void onAttachedToWindow() {
+ attachToControllerIfReady();
+ }
+
+ @Override
+ public void onDetachedFromWindow() {
+ if (mCameraController != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+ mCameraController.clearPreviewSurface();
+ }
+ }
+
+ /**
+ * 视图的Size变换后，重新给对焦类重新计算视图宽高
+ */
+ @Override
+ public void onSizeChanged() {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+ return;
+ }
+ mPreviewViewMeteringPointFactory.recalculate(new Size(mTouchView.getWidth(), mTouchView.getHeight()),
+ mTouchView.getLayoutDirection());
+ attachToControllerIfReady();
+ }
+
+ @Override
+ public void setTransformationInfo(SurfaceRequest.TransformationInfo transformationInfo, Size resolution, boolean isFrontCamera) {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+ return;
+ }
+ mPreviewTransform.setTransformationInfo(transformationInfo,
+ resolution, isFrontCamera);
+ mPreviewViewMeteringPointFactory.recalculate(new Size(mTouchView.getWidth(), mTouchView.getHeight()),
+ mTouchView.getLayoutDirection());
+ }
+
+
+ private void attachToControllerIfReady() {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+ return;
+ }
+ Display display = mTouchView.getDisplay();
+ ViewPort viewPort = getViewPort();
+ if (mCameraController != null && viewPort != null && mTouchView.isAttachedToWindow()
+ && display != null) {
+ try {
+ mCameraController.attachPreviewSurface(mTouchView.getSurfaceProvider().providerSurface(), viewPort, display);
+ } catch (IllegalStateException ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ }
+ }
+ }
+
+ private int getViewPortScaleType() {
+ return ViewPort.FILL_CENTER;
+ }
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/ForwardingLiveData.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/ForwardingLiveData.java
new file mode 100644
index 000000000..77c0997d5
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/ForwardingLiveData.java
@@ -0,0 +1,27 @@
+package com.quark.quamera.camerax.controller;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MediatorLiveData;
+
+final public class ForwardingLiveData extends MediatorLiveData {
+
+ private LiveData mLiveDataSource;
+
+ public void setSource(@NonNull LiveData liveDataSource) {
+ if (mLiveDataSource != null) {
+ super.removeSource(mLiveDataSource);
+ }
+ mLiveDataSource = liveDataSource;
+ super.addSource(liveDataSource, this::setValue);
+ }
+
+ @Override
+ public T getValue() {
+ // If MediatorLiveData has no active observers, it will not receive updates
+ // when the source is updated, in which case the value of this class and its source
+ // will be out-of-sync.
+ // We need to retrieve the source value for the caller.
+ return mLiveDataSource == null ? null : mLiveDataSource.getValue();
+ }
+}
\ No newline at end of file
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/ICameraViewTouchManager.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/ICameraViewTouchManager.java
new file mode 100644
index 000000000..8971edd0d
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/ICameraViewTouchManager.java
@@ -0,0 +1,38 @@
+package com.quark.quamera.camerax.controller;
+
+import android.util.Size;
+import android.view.MotionEvent;
+
+import androidx.annotation.UiThread;
+import androidx.camera.core.FocusMeteringResult;
+import androidx.camera.core.SurfaceRequest;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.quark.quamera.camerax.CameraController;
+
+/**
+ * @author : liujian
+ * @date : 2021/7/29
+ */
+public interface ICameraViewTouchManager {
+
+ @UiThread
+ void setCameraController(CameraController cameraController);
+
+ boolean onTouchEvent(MotionEvent event);
+
+ void performClick();
+
+ void onAttachedToWindow();
+
+ void onDetachedFromWindow();
+
+ void onSizeChanged();
+
+ void setTransformationInfo(SurfaceRequest.TransformationInfo transformationInfo, Size resolution, boolean isFrontCamera);
+
+ void setOnGestureDetectorListener(OnGestureDetectorListener listener);
+
+ ListenableFuture autoFocus(float x, float y, float size, long autoCancelTimes /*ms*/);
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/OnGestureDetectorListener.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/OnGestureDetectorListener.java
new file mode 100644
index 000000000..b82b8e82b
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/OnGestureDetectorListener.java
@@ -0,0 +1,14 @@
+package com.quark.quamera.camerax.controller;
+
+/**
+ * 点击对焦的事件回调
+ *
+ * @author : liujian
+ * @date : 2021/8/4
+ */
+public interface OnGestureDetectorListener {
+
+ void onClickFocused(float x, float y);
+
+ void onPinchToZoom(float zoomRatio, float maxZoomRatio, float minZoomRatio);
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/PreviewTransformation.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/PreviewTransformation.java
new file mode 100644
index 000000000..cb0a877dc
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/PreviewTransformation.java
@@ -0,0 +1,430 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camerax.controller;
+
+import android.annotation.SuppressLint;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.util.LayoutDirection;
+import android.util.Size;
+import android.view.Display;
+import android.view.Surface;
+import android.view.SurfaceView;
+import android.view.TextureView;
+import android.view.View;
+
+import com.quark.quamera.camerax.controller.internal.compat.quirk.PreviewOneThirdWiderQuirk;
+import com.quark.quamera.camerax.controller.internal.compat.quirk.TextureViewRotationQuirk;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import androidx.camera.camera2.internal.compat.quirk.DeviceQuirks;
+import androidx.camera.core.Logger;
+import androidx.camera.core.SurfaceRequest;
+import androidx.core.util.Preconditions;
+
+import static android.graphics.Paint.ANTI_ALIAS_FLAG;
+import static android.graphics.Paint.DITHER_FLAG;
+import static android.graphics.Paint.FILTER_BITMAP_FLAG;
+/**
+ * Handles {PreviewView} transformation.
+ *
+ * This class transforms the camera output and display it in a PreviewView. The goal is
+ * to transform it in a way so that the entire area of
+ * {@link SurfaceRequest.TransformationInfo#getCropRect()} is 1) visible to end users, and 2)
+ * displayed as large as possible.
+ *
+ *
The inputs for the calculation are 1) the dimension of the Surface, 2) the crop rect, 3) the
+ * dimension of the PreviewView and 4) rotation degrees:
+ *
+ *
+ * Source: +-----Surface-----+ Destination: +-----PreviewView----+
+ * | | | |
+ * | +-crop rect-+ | | |
+ * | | | | +--------------------+
+ * | | | |
+ * | | --> | | Rotation: <-----+
+ * | | | | 270°|
+ * | | | | |
+ * | +-----------+ |
+ * +-----------------+
+ *
+ * By mapping the Surface crop rect to match the PreviewView, we have:
+ *
+ * +------transformed Surface-------+
+ * | |
+ * | +----PreviewView-----+ |
+ * | | ^ | |
+ * | | | | |
+ * | +--------------------+ |
+ * | |
+ * +--------------------------------+
+ *
+ *
+ * The transformed Surface is how the PreviewView's inner view should behave, to make the
+ * crop rect matches the PreviewView.
+ */
+final class PreviewTransformation {
+
+ private static final String TAG = "PreviewTransform";
+
+
+ // SurfaceRequest.getResolution().
+ private Size mResolution;
+ // This represents the area of the Surface that should be visible to end users. The value
+ // is based on TransformationInfo.getCropRect() with possible corrections due to device quirks.
+ private Rect mSurfaceCropRect;
+ // This rect represents the size of the viewport in preview. It's always the same as
+ // TransformationInfo.getCropRect().
+ private Rect mViewportRect;
+ // TransformationInfo.getRotationDegrees().
+ private int mPreviewRotationDegrees;
+ // TransformationInfo.getTargetRotation.
+ private int mTargetRotation;
+ // Whether the preview is using front camera.
+ private boolean mIsFrontCamera;
+
+
+ PreviewTransformation() {
+ }
+
+ /**
+ * Sets the inputs.
+ *
+ *
All the values originally come from a {@link SurfaceRequest}.
+ */
+ @SuppressLint({"RestrictedApi", "UnsafeExperimentalUsageError"})
+ void setTransformationInfo(@NonNull SurfaceRequest.TransformationInfo transformationInfo,
+ Size resolution, boolean isFrontCamera) {
+ Logger.d(TAG, "Transformation info set: " + transformationInfo + " " + resolution + " "
+ + isFrontCamera);
+ mSurfaceCropRect = getCorrectedCropRect(transformationInfo.getCropRect());
+ mViewportRect = transformationInfo.getCropRect();
+ mPreviewRotationDegrees = transformationInfo.getRotationDegrees();
+ mTargetRotation = transformationInfo.getTargetRotation();
+ mResolution = resolution;
+ mIsFrontCamera = isFrontCamera;
+ }
+
+ /**
+ * Creates a matrix that makes {@link TextureView}'s rotation matches the
+ * {@link #mTargetRotation}.
+ *
+ *
The value should be applied by calling {@link TextureView#setTransform(Matrix)}. Usually
+ * {@link #mTargetRotation} is the display rotation. In that case, this
+ * matrix will just make a {@link TextureView} works like a {@link SurfaceView}. If not, then
+ * it will further correct it to the desired rotation.
+ *
+ *
This method is also needed in {@link #createTransformedBitmap} to correct the screenshot.
+ */
+ @SuppressLint("RestrictedApi")
+ @VisibleForTesting
+ Matrix getTextureViewCorrectionMatrix() {
+ Preconditions.checkState(isTransformationInfoReady());
+ RectF surfaceRect = new RectF(0, 0, mResolution.getWidth(), mResolution.getHeight());
+ @SuppressLint("RestrictedApi") int rotationDegrees = -TransformUtils.surfaceRotationToRotationDegrees(mTargetRotation);
+
+ TextureViewRotationQuirk textureViewRotationQuirk =
+ DeviceQuirks.get(TextureViewRotationQuirk.class);
+ if (textureViewRotationQuirk != null) {
+ rotationDegrees += textureViewRotationQuirk.getCorrectionRotation(mIsFrontCamera);
+ }
+ return TransformUtils.getRectToRect(surfaceRect, surfaceRect, rotationDegrees);
+ }
+
+ /**
+ * Calculates the transformation and applies it to the inner view ofPreviewView.
+ *
+ *
The inner view could be {@link SurfaceView} or a {@link TextureView}.
+ * {@link TextureView} needs a preliminary correction since it doesn't handle the
+ * display rotation.
+ */
+ @SuppressLint("RestrictedApi")
+ void transformView(Size previewViewSize, int layoutDirection, @NonNull View preview) {
+ if (previewViewSize.getHeight() == 0 || previewViewSize.getWidth() == 0) {
+ Logger.w(TAG, "Transform not applied due to PreviewView size: " + previewViewSize);
+ return;
+ }
+ if (!isTransformationInfoReady()) {
+ return;
+ }
+
+ if (preview instanceof TextureView) {
+ // For TextureView, correct the orientation to match the target rotation.
+ ((TextureView) preview).setTransform(getTextureViewCorrectionMatrix());
+ } else {
+ // Logs an error if non-display rotation is used with SurfaceView.
+ Display display = preview.getDisplay();
+ if (display != null && display.getRotation() != mTargetRotation) {
+ Logger.e(TAG, "Non-display rotation not supported with SurfaceView / PERFORMANCE "
+ + "mode.");
+ }
+ }
+
+ RectF surfaceRectInPreviewView = getTransformedSurfaceRect(previewViewSize,
+ layoutDirection);
+ preview.setPivotX(0);
+ preview.setPivotY(0);
+ preview.setScaleX(surfaceRectInPreviewView.width() / mResolution.getWidth());
+ preview.setScaleY(surfaceRectInPreviewView.height() / mResolution.getHeight());
+ preview.setTranslationX(surfaceRectInPreviewView.left - preview.getLeft());
+ preview.setTranslationY(surfaceRectInPreviewView.top - preview.getTop());
+ }
+
+ /**
+ * Gets the transformed {@link Surface} rect in PreviewView coordinates.
+ *
+ *
Returns desired rect of the inner view that once applied, the only part visible to
+ * end users is the crop rect.
+ */
+ @SuppressLint("RestrictedApi")
+ private RectF getTransformedSurfaceRect(Size previewViewSize, int layoutDirection) {
+ Preconditions.checkState(isTransformationInfoReady());
+ Matrix surfaceToPreviewView =
+ getSurfaceToPreviewViewMatrix(previewViewSize, layoutDirection);
+ RectF rect = new RectF(0, 0, mResolution.getWidth(), mResolution.getHeight());
+ surfaceToPreviewView.mapRect(rect);
+ return rect;
+ }
+
+ /**
+ * Calculates the transformation from {@link Surface} coordinates to PreviewView
+ * coordinates.
+ *
+ *
The calculation is based on making the crop rect to fill or fit the PreviewView.
+ */
+ @SuppressLint("RestrictedApi")
+ Matrix getSurfaceToPreviewViewMatrix(Size previewViewSize, int layoutDirection) {
+ Preconditions.checkState(isTransformationInfoReady());
+
+ // Get the target of the mapping, the coordinates of the crop rect in PreviewView.
+ RectF previewViewCropRect;
+ if (isViewportAspectRatioMatchPreviewView(previewViewSize)) {
+ // If crop rect has the same aspect ratio as PreviewView, scale the crop rect to fill
+ // the entire PreviewView. This happens if the scale type is FILL_* AND a
+ // PreviewView-based viewport is used.
+ previewViewCropRect = new RectF(0, 0, previewViewSize.getWidth(),
+ previewViewSize.getHeight());
+ } else {
+ // If the aspect ratios don't match, it could be 1) scale type is FIT_*, 2) the
+ // Viewport is not based on the PreviewView or 3) both.
+ previewViewCropRect = getPreviewViewViewportRectForMismatchedAspectRatios(
+ previewViewSize, layoutDirection);
+ }
+ Matrix matrix = TransformUtils.getRectToRect(new RectF(mSurfaceCropRect), previewViewCropRect,
+ mPreviewRotationDegrees);
+ if (mIsFrontCamera) {
+ // SurfaceView/TextureView automatically mirrors the Surface for front camera, which
+ // needs to be compensated by mirroring the Surface around the upright direction of the
+ // output image.
+ if (TransformUtils.is90or270(mPreviewRotationDegrees)) {
+ // If the rotation is 90/270, the Surface should be flipped vertically.
+ // +---+ 90 +---+ 270 +---+
+ // | ^ | --> | < | | > |
+ // +---+ +---+ +---+
+ matrix.preScale(1F, -1F, mSurfaceCropRect.centerX(), mSurfaceCropRect.centerY());
+ } else {
+ // If the rotation is 0/180, the Surface should be flipped horizontally.
+ // +---+ 0 +---+ 180 +---+
+ // | ^ | --> | ^ | | v |
+ // +---+ +---+ +---+
+ matrix.preScale(-1F, 1F, mSurfaceCropRect.centerX(), mSurfaceCropRect.centerY());
+ }
+ }
+ return matrix;
+ }
+
+ /**
+ * Gets the vertices of the crop rect in Surface.
+ */
+ @SuppressLint("RestrictedApi")
+ private Rect getCorrectedCropRect(Rect surfaceCropRect) {
+ PreviewOneThirdWiderQuirk quirk = DeviceQuirks.get(PreviewOneThirdWiderQuirk.class);
+ if (quirk != null) {
+ // Correct crop rect if the device has a quirk.
+ RectF cropRectF = new RectF(surfaceCropRect);
+ Matrix correction = new Matrix();
+ correction.setScale(
+ quirk.getCropRectScaleX(),
+ 1f,
+ surfaceCropRect.centerX(),
+ surfaceCropRect.centerY());
+ correction.mapRect(cropRectF);
+ Rect correctRect = new Rect();
+ cropRectF.round(correctRect);
+ return correctRect;
+ }
+ return surfaceCropRect;
+ }
+
+ /**
+ * Gets the viewport rect in PreviewView coordinates for the case where viewport's
+ * aspect ratio doesn't match PreviewView's aspect ratio.
+ *
+ *
When aspect ratios don't match, additional calculation is needed to figure out how to
+ * fit crop rect into the PreviewView
+ */
+ RectF getPreviewViewViewportRectForMismatchedAspectRatios(Size previewViewSize,
+ int layoutDirection) {
+ RectF previewViewRect = new RectF(0, 0, previewViewSize.getWidth(),
+ previewViewSize.getHeight());
+ Size rotatedViewportSize = getRotatedViewportSize();
+ RectF rotatedViewportRect = new RectF(0, 0, rotatedViewportSize.getWidth(),
+ rotatedViewportSize.getHeight());
+ Matrix matrix = new Matrix();
+ setMatrixRectToRect(matrix, rotatedViewportRect, previewViewRect);
+ matrix.mapRect(rotatedViewportRect);
+ if (layoutDirection == LayoutDirection.RTL) {
+ return flipHorizontally(rotatedViewportRect, (float) previewViewSize.getWidth() / 2);
+ }
+ return rotatedViewportRect;
+ }
+
+ /**
+ * Set the matrix that maps the source rectangle to the destination rectangle.
+ *
+ *
This static method is an extension of {@link Matrix#setRectToRect} with an additional
+ * support for FILL_* types.
+ */
+ private static void setMatrixRectToRect(Matrix matrix, RectF source, RectF destination) {
+ Matrix.ScaleToFit matrixScaleType = Matrix.ScaleToFit.FILL;
+ // TODO: 后续可能需要更改ScaleType
+// boolean isFitTypes =
+// scaleType == FIT_CENTER || scaleType == FIT_START || scaleType == FIT_END;
+ boolean isFitTypes = false;
+ if (isFitTypes) {
+ matrix.setRectToRect(source, destination, matrixScaleType);
+ } else {
+ // android.graphics.Matrix doesn't support fill scale types. The workaround is
+ // mapping inversely from destination to source, then invert the matrix.
+ matrix.setRectToRect(destination, source, matrixScaleType);
+ matrix.invert(matrix);
+ }
+ }
+
+ /**
+ * Flips the given rect along a vertical line for RTL layout direction.
+ */
+ private static RectF flipHorizontally(RectF original, float flipLineX) {
+ return new RectF(
+ flipLineX + flipLineX - original.right,
+ original.top,
+ flipLineX + flipLineX - original.left,
+ original.bottom);
+ }
+
+ /**
+ * Returns viewport size with target rotation applied.
+ */
+ @SuppressLint("RestrictedApi")
+ private Size getRotatedViewportSize() {
+ if (TransformUtils.is90or270(mPreviewRotationDegrees)) {
+ return new Size(mViewportRect.height(), mViewportRect.width());
+ }
+ return new Size(mViewportRect.width(), mViewportRect.height());
+ }
+
+ /**
+ * Checks if the viewport's aspect ratio matches that of the PreviewView.
+ */
+ @SuppressLint("RestrictedApi")
+ @VisibleForTesting
+ boolean isViewportAspectRatioMatchPreviewView(Size previewViewSize) {
+ // Using viewport rect to check if the viewport is based on the PreviewView.
+ Size rotatedViewportSize = getRotatedViewportSize();
+ return TransformUtils.isAspectRatioMatchingWithRoundingError(
+ previewViewSize, /* isAccurate1= */ true,
+ rotatedViewportSize, /* isAccurate2= */ false);
+ }
+
+ /**
+ * Return the crop rect of the preview surface.
+ */
+ @Nullable
+ Rect getSurfaceCropRect() {
+ return mSurfaceCropRect;
+ }
+
+ /**
+ * Creates a transformed screenshot of PreviewView.
+ *
+ *
Creates the transformed {@link Bitmap} by applying the same transformation applied to
+ * the inner view. T
+ *
+ * @param original a snapshot of the untransformed inner view.
+ */
+ Bitmap createTransformedBitmap(@NonNull Bitmap original, Size previewViewSize,
+ int layoutDirection) {
+ if (!isTransformationInfoReady()) {
+ return original;
+ }
+ Matrix textureViewCorrection = getTextureViewCorrectionMatrix();
+ RectF surfaceRectInPreviewView = getTransformedSurfaceRect(previewViewSize,
+ layoutDirection);
+
+ Bitmap transformed = Bitmap.createBitmap(
+ previewViewSize.getWidth(), previewViewSize.getHeight(), original.getConfig());
+ Canvas canvas = new Canvas(transformed);
+
+ Matrix canvasTransform = new Matrix();
+ canvasTransform.postConcat(textureViewCorrection);
+ canvasTransform.postScale(surfaceRectInPreviewView.width() / mResolution.getWidth(),
+ surfaceRectInPreviewView.height() / mResolution.getHeight());
+ canvasTransform.postTranslate(surfaceRectInPreviewView.left, surfaceRectInPreviewView.top);
+
+ canvas.drawBitmap(original, canvasTransform,
+ new Paint(ANTI_ALIAS_FLAG | FILTER_BITMAP_FLAG | DITHER_FLAG));
+ return transformed;
+ }
+
+ /**
+ * Calculates the mapping from a UI touch point (0, 0) - (width, height) to normalized
+ * space (-1, -1) - (1, 1).
+ *
+ *
This is used by {@link PreviewViewMeteringPointFactory}.
+ *
+ * @return null if transformation info is not set.
+ */
+ @Nullable
+ Matrix getPreviewViewToNormalizedSurfaceMatrix(Size previewViewSize, int layoutDirection) {
+ if (!isTransformationInfoReady()) {
+ return null;
+ }
+ Matrix matrix = new Matrix();
+
+ // Map PreviewView coordinates to Surface coordinates.
+ getSurfaceToPreviewViewMatrix(previewViewSize, layoutDirection).invert(matrix);
+
+ // Map Surface coordinates to normalized coordinates (-1, -1) - (1, 1).
+ Matrix normalization = new Matrix();
+ normalization.setRectToRect(
+ new RectF(0, 0, mResolution.getWidth(), mResolution.getHeight()),
+ new RectF(0, 0, 1, 1), Matrix.ScaleToFit.FILL);
+ matrix.postConcat(normalization);
+
+ return matrix;
+ }
+
+ private boolean isTransformationInfoReady() {
+ return mSurfaceCropRect != null && mResolution != null;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/PreviewViewMeteringPointFactory.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/PreviewViewMeteringPointFactory.java
new file mode 100644
index 000000000..db4b46425
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/PreviewViewMeteringPointFactory.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camerax.controller;
+
+import android.graphics.Matrix;
+import android.graphics.PointF;
+import android.os.Build;
+import android.util.Size;
+
+import androidx.annotation.AnyThread;
+import androidx.annotation.GuardedBy;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.UiThread;
+import androidx.camera.core.MeteringPointFactory;
+
+
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+public class PreviewViewMeteringPointFactory extends MeteringPointFactory {
+
+ static final PointF INVALID_POINT = new PointF(2F, 2F);
+
+ @NonNull
+ private final PreviewTransformation mPreviewTransformation;
+
+ @GuardedBy("this")
+ @Nullable
+ private Matrix mMatrix;
+
+ PreviewViewMeteringPointFactory(@NonNull PreviewTransformation previewTransformation) {
+ mPreviewTransformation = previewTransformation;
+ }
+
+ @AnyThread
+ @NonNull
+ @Override
+ protected PointF convertPoint(float x, float y) {
+ float[] point = new float[]{x, y};
+ synchronized (this) {
+ if (mMatrix == null) {
+ return INVALID_POINT;
+ }
+ mMatrix.mapPoints(point);
+ }
+ return new PointF(point[0], point[1]);
+ }
+
+ @UiThread
+ void recalculate(@NonNull Size previewViewSize, int layoutDirection) {
+ synchronized (this) {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+ return;
+ }
+ if (previewViewSize.getWidth() == 0 || previewViewSize.getHeight() == 0) {
+ mMatrix = null;
+ return;
+ }
+ mMatrix = mPreviewTransformation.getPreviewViewToNormalizedSurfaceMatrix(
+ previewViewSize,
+ layoutDirection);
+ }
+ }
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/RotationReceiver.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/RotationReceiver.java
new file mode 100644
index 000000000..02da6b660
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/RotationReceiver.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camerax.controller;
+
+import android.content.Context;
+import android.view.OrientationEventListener;
+import android.view.Surface;
+
+import androidx.annotation.NonNull;
+
+
+public abstract class RotationReceiver {
+
+ private static final int INVALID_SURFACE_ROTATION = -1;
+
+ // Synthetic access
+ @SuppressWarnings("WeakerAccess")
+ int mRotation = INVALID_SURFACE_ROTATION;
+
+ private final OrientationEventListener mOrientationEventListener;
+
+ public RotationReceiver(@NonNull Context context) {
+ mOrientationEventListener = new OrientationEventListener(context) {
+ @Override
+ public void onOrientationChanged(int orientation) {
+ if (orientation == OrientationEventListener.ORIENTATION_UNKNOWN) {
+ // Short-circuit if orientation is unknown. Unknown rotation can't be handled
+ // so it shouldn't be sent.
+ return;
+ }
+
+ int newRotation;
+ if (orientation >= 315 || orientation < 45) {
+ newRotation = Surface.ROTATION_0;
+ } else if (orientation >= 225) {
+ newRotation = Surface.ROTATION_90;
+ } else if (orientation >= 135) {
+ newRotation = Surface.ROTATION_180;
+ } else {
+ newRotation = Surface.ROTATION_270;
+ }
+ if (mRotation != newRotation) {
+ mRotation = newRotation;
+ onRotationChanged(newRotation);
+ }
+ }
+ };
+ }
+
+ /**
+ * Checks if the RotationReceiver can detect orientation changes.
+ *
+ * @see OrientationEventListener#canDetectOrientation()
+ */
+ public boolean canDetectOrientation() {
+ return mOrientationEventListener.canDetectOrientation();
+ }
+
+ /**
+ * Enables the RotationReceiver so it will monitor the sensor and call onRotationChanged when
+ * the device orientation changes.
+ *
+ *
By default, the receiver is not enabled.
+ *
+ * @see OrientationEventListener#enable()
+ */
+ public void enable() {
+ mOrientationEventListener.enable();
+ }
+
+ /**
+ * Disables the RotationReceiver.
+ *
+ * @see OrientationEventListener#disable()
+ */
+ public void disable() {
+ mOrientationEventListener.disable();
+ }
+
+ /**
+ * Called when the physical rotation of the device changes.
+ *
+ *
The rotation is one of the {@link Surface} rotations mapped from orientation
+ * degrees.
+ *
+ *
+ * | Orientation degrees | Surface rotation |
|---|
+ * | [-45°, 45°) | {@link Surface#ROTATION_0} |
+ * | [45°, 135°) | {@link Surface#ROTATION_270} |
+ * | [135°, 225°) | {@link Surface#ROTATION_180} |
+ * | [225°, 315°) | {@link Surface#ROTATION_90} |
+ *
+ *
+ * @see OrientationEventListener#onOrientationChanged(int)
+ */
+ public abstract void onRotationChanged(int rotation);
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/TransformUtils.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/TransformUtils.java
new file mode 100644
index 000000000..1ac010122
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/TransformUtils.java
@@ -0,0 +1,288 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camerax.controller;
+
+import android.graphics.Matrix;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.media.ExifInterface;
+import android.util.Size;
+import android.view.Surface;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+
+/**
+ * Utility class for transform.
+ *
+ * The vertices representation uses a float array to represent a rectangle with arbitrary
+ * rotation and rotation-direction. It could be otherwise represented by a triple of a
+ * {@link RectF}, a rotation degrees integer and a boolean flag for the rotation-direction
+ * (clockwise v.s. counter-clockwise).
+ *
+ * TODO(b/179827713): merge this with {@link androidx.camera.core.internal.utils.ImageUtil}.
+ *
+ * @hide
+ */
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+public class TransformUtils {
+
+ // Normalized space (-1, -1) - (1, 1).
+ public static final RectF NORMALIZED_RECT = new RectF(-1, -1, 1, 1);
+
+ private TransformUtils() {
+ }
+
+ /**
+ * Gets the size of the {@link Rect}.
+ */
+ @NonNull
+ public static Size rectToSize(@NonNull Rect rect) {
+ return new Size(rect.width(), rect.height());
+ }
+
+ /**
+ * Converts an array of vertices to a {@link RectF}.
+ */
+ @NonNull
+ public static RectF verticesToRect(@NonNull float[] vertices) {
+ return new RectF(
+ min(vertices[0], vertices[2], vertices[4], vertices[6]),
+ min(vertices[1], vertices[3], vertices[5], vertices[7]),
+ max(vertices[0], vertices[2], vertices[4], vertices[6]),
+ max(vertices[1], vertices[3], vertices[5], vertices[7])
+ );
+ }
+
+ /**
+ * Returns the max value.
+ */
+ public static float max(float value1, float value2, float value3, float value4) {
+ return Math.max(Math.max(value1, value2), Math.max(value3, value4));
+ }
+
+ /**
+ * Returns the min value.
+ */
+ public static float min(float value1, float value2, float value3, float value4) {
+ return Math.min(Math.min(value1, value2), Math.min(value3, value4));
+ }
+
+ /**
+ * Converts {@link Surface} rotation to rotation degrees: 90, 180, 270 or 0.
+ */
+ public static int surfaceRotationToRotationDegrees(int rotationValue) {
+ switch (rotationValue) {
+ case Surface.ROTATION_0:
+ return 0;
+ case Surface.ROTATION_90:
+ return 90;
+ case Surface.ROTATION_180:
+ return 180;
+ case Surface.ROTATION_270:
+ return 270;
+ default:
+ throw new IllegalStateException("Unexpected rotation value " + rotationValue);
+ }
+ }
+
+ /**
+ * Returns true if the rotation degrees is 90 or 270.
+ */
+ public static boolean is90or270(int rotationDegrees) {
+ if (rotationDegrees == 90 || rotationDegrees == 270) {
+ return true;
+ }
+ if (rotationDegrees == 0 || rotationDegrees == 180) {
+ return false;
+ }
+ throw new IllegalArgumentException("Invalid rotation degrees: " + rotationDegrees);
+ }
+
+ /**
+ * Converts a {@link Size} to a float array of vertices.
+ */
+ @NonNull
+ public static float[] sizeToVertices(@NonNull Size size) {
+ return new float[]{0, 0, size.getWidth(), 0, size.getWidth(), size.getHeight(), 0,
+ size.getHeight()};
+ }
+
+ /**
+ * Converts a {@link RectF} defined by top, left, right and bottom to an array of vertices.
+ */
+ @NonNull
+ public static float[] rectToVertices(@NonNull RectF rectF) {
+ return new float[]{rectF.left, rectF.top, rectF.right, rectF.top, rectF.right, rectF.bottom,
+ rectF.left, rectF.bottom};
+ }
+
+ /**
+ * Checks if aspect ratio matches while tolerating rounding error.
+ *
+ *
One example of the usage is comparing the viewport-based crop rect from different use
+ * cases. The crop rect is rounded because pixels are integers, which may introduce an error
+ * when we check if the aspect ratio matches. For example, when PreviewView's
+ * width/height are prime numbers 601x797, the crop rect from other use cases cannot have a
+ * matching aspect ratio even if they are based on the same viewport. This method checks the
+ * aspect ratio while tolerating a rounding error.
+ *
+ * @param size1 the rounded size1
+ * @param isAccurate1 if size1 is accurate. e.g. it's true if it's the PreviewView's
+ * dimension which viewport is based on
+ * @param size2 the rounded size2
+ * @param isAccurate2 if size2 is accurate.
+ */
+ public static boolean isAspectRatioMatchingWithRoundingError(
+ @NonNull Size size1, boolean isAccurate1, @NonNull Size size2, boolean isAccurate2) {
+ // The crop rect coordinates are rounded values. Each value is at most .5 away from their
+ // true values. So the width/height, which is the difference of 2 coordinates, are at most
+ // 1.0 away from their true value.
+ // First figure out the possible range of the aspect ratio's ture value.
+ float ratio1UpperBound;
+ float ratio1LowerBound;
+ if (isAccurate1) {
+ ratio1UpperBound = (float) size1.getWidth() / size1.getHeight();
+ ratio1LowerBound = ratio1UpperBound;
+ } else {
+ ratio1UpperBound = (size1.getWidth() + 1F) / (size1.getHeight() - 1F);
+ ratio1LowerBound = (size1.getWidth() - 1F) / (size1.getHeight() + 1F);
+ }
+ float ratio2UpperBound;
+ float ratio2LowerBound;
+ if (isAccurate2) {
+ ratio2UpperBound = (float) size2.getWidth() / size2.getHeight();
+ ratio2LowerBound = ratio2UpperBound;
+ } else {
+ ratio2UpperBound = (size2.getWidth() + 1F) / (size2.getHeight() - 1F);
+ ratio2LowerBound = (size2.getWidth() - 1F) / (size2.getHeight() + 1F);
+ }
+ // Then we check if the true value range overlaps.
+ return ratio1UpperBound >= ratio2LowerBound && ratio2UpperBound >= ratio1LowerBound;
+ }
+
+ /**
+ * Gets the transform from one {@link Rect} to another with rotation degrees.
+ *
+ *
Following is how the source is mapped to the target with a 90° rotation. The rect
+ * is mapped to .
+ *
+ *
+ * a----------b d'-----------a'
+ * | source | -90°-> | |
+ * d----------c | target |
+ * | |
+ * c'-----------b'
+ *
+ */
+ @NonNull
+ public static Matrix getRectToRect(
+ @NonNull RectF source, @NonNull RectF target, int rotationDegrees) {
+ // Map source to normalized space.
+ Matrix matrix = new Matrix();
+ matrix.setRectToRect(source, NORMALIZED_RECT, Matrix.ScaleToFit.FILL);
+ // Add rotation.
+ matrix.postRotate(rotationDegrees);
+ // Restore the normalized space to target's coordinates.
+ matrix.postConcat(getNormalizedToBuffer(target));
+ return matrix;
+ }
+
+ /**
+ * Gets the transform from a normalized space (-1, -1) - (1, 1) to the given rect.
+ */
+ @NonNull
+ public static Matrix getNormalizedToBuffer(@NonNull Rect viewPortRect) {
+ return getNormalizedToBuffer(new RectF(viewPortRect));
+ }
+
+ /**
+ * Gets the transform from a normalized space (-1, -1) - (1, 1) to the given rect.
+ */
+ @NonNull
+ private static Matrix getNormalizedToBuffer(@NonNull RectF viewPortRect) {
+ Matrix normalizedToBuffer = new Matrix();
+ normalizedToBuffer.setRectToRect(NORMALIZED_RECT, viewPortRect, Matrix.ScaleToFit.FILL);
+ return normalizedToBuffer;
+ }
+
+ /**
+ * Gets the transform matrix based on exif orientation.
+ */
+ @NonNull
+ public static Matrix getExifTransform(int exifOrientation, int width, int height) {
+ Matrix matrix = new Matrix();
+
+ // Map the bitmap to a normalized space and perform transform. It's more readable, and it
+ // can be tested with Robolectric's ShadowMatrix (Matrix#setPolyToPoly is currently not
+ // shadowed by ShadowMatrix).
+ RectF rect = new RectF(0, 0, width, height);
+ matrix.setRectToRect(rect, NORMALIZED_RECT, Matrix.ScaleToFit.FILL);
+
+ // A flag that checks if the image has been rotated 90/270.
+ boolean isWidthHeightSwapped = false;
+
+ // Transform the normalized space based on exif orientation.
+ switch (exifOrientation) {
+ case ExifInterface.ORIENTATION_FLIP_HORIZONTAL:
+ matrix.postScale(-1f, 1f);
+ break;
+ case ExifInterface.ORIENTATION_ROTATE_180:
+ matrix.postRotate(180);
+ break;
+ case ExifInterface.ORIENTATION_FLIP_VERTICAL:
+ matrix.postScale(1f, -1f);
+ break;
+ case ExifInterface.ORIENTATION_TRANSPOSE:
+ // Flipped about top-left <--> bottom-right axis, it can also be represented by
+ // flip horizontally and then rotate 270 degree clockwise.
+ matrix.postScale(-1f, 1f);
+ matrix.postRotate(270);
+ isWidthHeightSwapped = true;
+ break;
+ case ExifInterface.ORIENTATION_ROTATE_90:
+ matrix.postRotate(90);
+ isWidthHeightSwapped = true;
+ break;
+ case ExifInterface.ORIENTATION_TRANSVERSE:
+ // Flipped about top-right <--> bottom left axis, it can also be represented by
+ // flip horizontally and then rotate 90 degree clockwise.
+ matrix.postScale(-1f, 1f);
+ matrix.postRotate(90);
+ isWidthHeightSwapped = true;
+ break;
+ case ExifInterface.ORIENTATION_ROTATE_270:
+ matrix.postRotate(270);
+ isWidthHeightSwapped = true;
+ break;
+ case ExifInterface.ORIENTATION_NORMAL:
+ // Fall-through
+ case ExifInterface.ORIENTATION_UNDEFINED:
+ // Fall-through
+ default:
+ break;
+ }
+
+ // Map the normalized space back to the bitmap coordinates.
+ RectF restoredRect = isWidthHeightSwapped ? new RectF(0, 0, height, width) : rect;
+ Matrix restore = new Matrix();
+ restore.setRectToRect(NORMALIZED_RECT, restoredRect, Matrix.ScaleToFit.FILL);
+ matrix.postConcat(restore);
+
+ return matrix;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/DeviceQuirks.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/DeviceQuirks.java
new file mode 100644
index 000000000..7b161e858
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/DeviceQuirks.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camerax.controller.internal.compat.quirk;
+
+import android.annotation.SuppressLint;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.camera.core.impl.Quirk;
+import androidx.camera.core.impl.Quirks;
+
+/**
+ * Provider of device specific quirks for the view module, which are used for device specific
+ * workarounds.
+ *
+ * Device specific quirks depend on device properties, including the manufacturer
+ * ({@link android.os.Build#MANUFACTURER}), model ({@link android.os.Build#MODEL}) and OS
+ * level ({@link android.os.Build.VERSION#SDK_INT}).
+ *
+ * Device specific quirks are lazily loaded, i.e. They are loaded the first time they're needed.
+ */
+@SuppressLint("RestrictedApi")
+public class DeviceQuirks {
+
+ @NonNull
+ private static final Quirks QUIRKS;
+
+ static {
+ QUIRKS = new Quirks(DeviceQuirksLoader.loadQuirks());
+ }
+
+ private DeviceQuirks() {
+ }
+
+ /**
+ * Retrieves a specific device {@link Quirk} instance given its type.
+ *
+ * @param quirkClass The type of device quirk to retrieve.
+ * @return A device {@link Quirk} instance of the provided type, or {@code null} if it isn't
+ * found.
+ */
+ @Nullable
+ public static T get(@NonNull final Class quirkClass) {
+ return QUIRKS.get(quirkClass);
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/DeviceQuirksLoader.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/DeviceQuirksLoader.java
new file mode 100644
index 000000000..c838ff5c0
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/DeviceQuirksLoader.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camerax.controller.internal.compat.quirk;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.camera.core.impl.Quirk;
+
+/**
+ * Loads all device specific quirks required for the current device
+ */
+public class DeviceQuirksLoader {
+
+ private DeviceQuirksLoader() {
+ }
+
+ /**
+ * Goes through all defined device-specific quirks, and returns those that should be loaded
+ * on the current device.
+ */
+ @NonNull
+ static List loadQuirks() {
+ final List quirks = new ArrayList<>();
+
+ // Load all device specific quirks
+ if (PreviewOneThirdWiderQuirk.load()) {
+ quirks.add(new PreviewOneThirdWiderQuirk());
+ }
+
+ if (SurfaceViewStretchedQuirk.load()) {
+ quirks.add(new SurfaceViewStretchedQuirk());
+ }
+
+ if (TextureViewRotationQuirk.load()) {
+ quirks.add(new TextureViewRotationQuirk());
+ }
+
+ return quirks;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/PreviewOneThirdWiderQuirk.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/PreviewOneThirdWiderQuirk.java
new file mode 100644
index 000000000..d3b1a5b17
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/PreviewOneThirdWiderQuirk.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camerax.controller.internal.compat.quirk;
+
+import android.os.Build;
+
+import androidx.camera.core.impl.Quirk;
+
+/**
+ * A quirk where the preview buffer is stretched.
+ *
+ * The symptom is, the preview's FOV is always 1/3 wider than intended. For example, if the
+ * preview Surface is 800x600, it's actually has a FOV of 1066x600 with the same center point,
+ * but squeezed to fit the 800x600 buffer.
+ */
+public class PreviewOneThirdWiderQuirk implements Quirk {
+
+ private static final String SAMSUNG_A3_2017 = "A3Y17LTE"; // b/180121821
+ private static final String SAMSUNG_J5_PRIME = "ON5XELTE"; // b/183329599
+
+ static boolean load() {
+ boolean isSamsungJ5PrimeAndApi26 =
+ SAMSUNG_J5_PRIME.equals(Build.DEVICE.toUpperCase()) && Build.VERSION.SDK_INT >= 26;
+ boolean isSamsungA3 = SAMSUNG_A3_2017.equals(Build.DEVICE.toUpperCase());
+ return isSamsungJ5PrimeAndApi26 || isSamsungA3;
+ }
+
+ /**
+ * The mount that the crop rect needs to be scaled in x.
+ */
+ public float getCropRectScaleX() {
+ return 0.75f;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/SurfaceViewStretchedQuirk.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/SurfaceViewStretchedQuirk.java
new file mode 100644
index 000000000..e796167cd
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/SurfaceViewStretchedQuirk.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camerax.controller.internal.compat.quirk;
+
+import android.os.Build;
+
+import androidx.camera.core.impl.Quirk;
+
+/**
+ * A quirk where SurfaceView is stretched.
+ *
+ *
On Samsung Galaxy Z Fold2, transform APIs (e.g. View#setScaleX) do not work as intended.
+ * b/129403806
+ */
+public class SurfaceViewStretchedQuirk implements Quirk {
+
+ // Samsung Galaxy Z Fold2 b/129403806
+ private static final String SAMSUNG = "SAMSUNG";
+ private static final String GALAXY_Z_FOLD_2 = "F2Q";
+
+ static boolean load() {
+ return SAMSUNG.equals(Build.MANUFACTURER.toUpperCase()) && GALAXY_Z_FOLD_2.equals(
+ Build.DEVICE.toUpperCase());
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/TextureViewRotationQuirk.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/TextureViewRotationQuirk.java
new file mode 100644
index 000000000..369cdd370
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/controller/internal/compat/quirk/TextureViewRotationQuirk.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camerax.controller.internal.compat.quirk;
+
+import android.os.Build;
+import android.view.TextureView;
+
+import androidx.camera.core.impl.Quirk;
+
+/**
+ * A quirk that requires applying extra rotation on {@link TextureView}
+ *
+ *
On certain devices, the rotation of the output is incorrect. One example is b/177561470.
+ * In which case, the extra rotation is needed to correct the output on {@link TextureView}.
+ */
+public class TextureViewRotationQuirk implements Quirk {
+
+ private static final String FAIRPHONE = "Fairphone";
+ private static final String FAIRPHONE_2_MODEL = "FP2";
+
+ static boolean load() {
+ return isFairphone2();
+ }
+
+ /**
+ * Gets correction needed for the given camera.
+ */
+ public int getCorrectionRotation(boolean isFrontCamera) {
+ if (isFairphone2() && isFrontCamera) {
+ // On Fairphone2, the front camera output on TextureView is rotated 180°.
+ // See: b/177561470.
+ return 180;
+ }
+ return 0;
+ }
+
+ private static boolean isFairphone2() {
+ return FAIRPHONE.equalsIgnoreCase(Build.MANUFACTURER)
+ && FAIRPHONE_2_MODEL.equalsIgnoreCase(Build.MODEL);
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/filter/CameraIdLensFacingCameraFilter.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/filter/CameraIdLensFacingCameraFilter.java
new file mode 100644
index 000000000..69f706626
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/filter/CameraIdLensFacingCameraFilter.java
@@ -0,0 +1,53 @@
+package com.quark.quamera.camerax.filter;
+
+import android.annotation.SuppressLint;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.camera.core.CameraInfo;
+import androidx.camera.core.CameraSelector;
+import androidx.camera.core.impl.CameraInfoInternal;
+import androidx.camera.core.impl.LensFacingCameraFilter;
+import androidx.core.util.Preconditions;
+
+/**
+ * @author : liujian
+ * @date : 2021/7/30
+ */
+@SuppressLint({"UnsafeExperimentalUsageError", "RestrictedApi", "UnsafeOptInUsageError"})
+public class CameraIdLensFacingCameraFilter extends LensFacingCameraFilter {
+
+ @CameraSelector.LensFacing
+ private final int mLensFacing;
+ @NonNull
+ private final String mCameraId;
+
+ @SuppressLint("RestrictedApi")
+ public CameraIdLensFacingCameraFilter(int lensFacing, @NonNull String cameraId) {
+ super(lensFacing);
+ this.mLensFacing = lensFacing;
+ this.mCameraId = cameraId;
+ }
+
+ @NonNull
+ @Override
+ public List filter(@NonNull List cameraInfos) {
+ List result = new ArrayList<>();
+ for (CameraInfo cameraInfo : cameraInfos) {
+ Preconditions.checkArgument(cameraInfo instanceof CameraInfoInternal,
+ "The camera info doesn't contain internal implementation.");
+ Integer lensFacing = ((CameraInfoInternal) cameraInfo).getLensFacing();
+ String cameraId = ((CameraInfoInternal) cameraInfo).getCameraId();
+ if (lensFacing != null && lensFacing == mLensFacing && mCameraId.equals(cameraId)) {
+ result.add(cameraInfo);
+ }
+ }
+
+ if (result.isEmpty() && !cameraInfos.isEmpty()){
+ result.add(cameraInfos.get(0));
+ }
+ return result;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/utils/CameraXCaptureResultManager.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/utils/CameraXCaptureResultManager.java
new file mode 100644
index 000000000..52df523ef
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/utils/CameraXCaptureResultManager.java
@@ -0,0 +1,170 @@
+package com.quark.quamera.camerax.utils;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/5/26
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.annotation.SuppressLint;
+import android.hardware.camera2.CaptureResult;
+import android.os.Build;
+import android.util.Log;
+
+import com.quark.quamera.render.DefaultCameraRender;
+import com.quark.quamera.util.CameraInit;
+import com.quark.quamera.util.CameraReflection;
+
+import java.lang.ref.WeakReference;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Queue;
+
+import androidx.annotation.RequiresApi;
+import androidx.camera.camera2.internal.Camera2CameraCaptureResult;
+
+/**
+ * 立即释放CaptureResult中CameraMetadataNative持有的Native内存
+ *
+ * CameraMetadataNative 默认情况下是执行GC的时候，会释放C++内存，但是会不及时，因为Native Heap上涨不会导致GC触发，但是会导致OOM
+ *
+ * 目前的方式通过反射实现，存在一定的兼容性风险；对于而已。GC+内存检测兼容性好点，但是性能可能没有那么好
+ */
+public class CameraXCaptureResultManager {
+
+ public final static String TAG = "Camera2MemManager";
+ private int mMaxCache = 40;
+ private boolean mEnable = true;
+
+ public CameraXCaptureResultManager() {
+ this(40);
+ }
+
+ public CameraXCaptureResultManager(int maxCache) {
+ this.mMaxCache = maxCache;
+ mEnable = CameraInit.getConfig().enableHighMemoryGC();
+ }
+
+
+ private final Queue> mCacheCacheResult = new LinkedList<>();
+
+ public void cacheCaptureResult(Camera2CameraCaptureResult captureResult) {
+ if (!mEnable) {
+ return;
+ }
+
+ if (captureResult == null) {
+ return;
+ }
+ synchronized (mCacheCacheResult) {
+ if (mCacheCacheResult.size() > mMaxCache) {
+ mCacheCacheResult.remove();
+ }
+ mCacheCacheResult.add(new WeakReference<>(captureResult));
+ }
+ }
+
+ /**
+ * 消费并且删除 相对于 surfaceTimeStamp 过期的Result
+ * 基于假设 SurfaceTexture的队列timestamp一定是递增的
+ */
+ @SuppressLint("RestrictedApi")
+ public Camera2CameraCaptureResult consumeMatchCaptureResult(long surfaceTimeStamp) {
+ if (!mEnable) {
+ return null;
+ }
+ synchronized (mCacheCacheResult) {
+ Iterator> it = mCacheCacheResult.iterator();
+ while (it.hasNext()) {
+ Camera2CameraCaptureResult result = it.next().get();
+ if (result == null) {
+ it.remove();
+ continue;
+ }
+ try {
+ if (result.getTimestamp() < surfaceTimeStamp) {
+ //移除掉时间比较小的
+ it.remove();
+ }
+ if (result.getTimestamp() == surfaceTimeStamp) {
+ it.remove();
+ return result;
+ }
+ } catch (Exception e) {
+ Log.d(DefaultCameraRender.TAG, "CaptureFrameHelper.consumeMatchCaptureResult --- " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
+ return null;
+ }
+ }
+
+ public void clear() {
+ synchronized (mCacheCacheResult) {
+ mCacheCacheResult.clear();
+ }
+ }
+
+
+ private static Field sCameraMetaDataNativeField;
+ private static Method sCameraMetaDataCloseMethod;
+ private static Class sClass;
+
+ /**
+ * 立即释放CaptureResult中CameraMetadataNative持有的Native内存
+ *
+ * CameraMetadataNative 默认情况下是执行GC的时候，会释放C++内存，但是会不及时，因为Native Heap上涨不会导致GC触发，但是会导致OOM
+ */
+ @SuppressLint("RestrictedApi")
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ public boolean releaseCaptureResultNow(Camera2CameraCaptureResult captureResult) {
+ if (!mEnable) {
+ return false;
+ }
+
+ if (captureResult == null || captureResult.getCaptureResult() == null) {
+ return false;
+ }
+ try {
+ if (sCameraMetaDataNativeField == null) {
+ sCameraMetaDataNativeField = CaptureResult.class.getDeclaredField("mResults");
+ sCameraMetaDataNativeField.setAccessible(true);
+ }
+
+ if (sClass == null) {
+ sClass = Class.forName("android.hardware.camera2.impl.CameraMetadataNative");
+ }
+
+ if (sCameraMetaDataCloseMethod == null) {
+ sCameraMetaDataCloseMethod = CameraReflection.findMethod(sClass, "finalize");
+ sCameraMetaDataCloseMethod.setAccessible(true);
+ }
+
+ } catch (NoSuchFieldException e) {
+ e.printStackTrace();
+ } catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ } catch (NoSuchMethodException e) {
+ e.printStackTrace();
+ }
+
+ if (sCameraMetaDataCloseMethod == null || sCameraMetaDataNativeField == null) {
+ return false;
+ }
+
+ try {
+ long timeState = captureResult.getTimestamp();
+ sCameraMetaDataCloseMethod.invoke(sCameraMetaDataNativeField.get(captureResult.getCaptureResult()));
+ Log.d(DefaultCameraRender.TAG, "CaptureFrameHelper.release --- " + timeState);
+ return true;
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ return false;
+ }
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/utils/FocalLengthInfo.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/utils/FocalLengthInfo.java
new file mode 100644
index 000000000..0e5204c70
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/utils/FocalLengthInfo.java
@@ -0,0 +1,21 @@
+package com.quark.quamera.camerax.utils;
+
+public class FocalLengthInfo implements Comparable {
+ public float focalLength = Float.MAX_VALUE;
+ public double horizontalAngle = 0; //0 ~ pi
+ public double verticalAngle = 0; //0 ~ pi
+ public boolean isDefaultFocal = false;
+
+ @Override
+ public int compareTo(FocalLengthInfo o) {
+ if (o == this) {
+ return 0;
+ }
+ //never happen
+ if (focalLength == o.focalLength) {
+ return 0;
+ }
+
+ return focalLength > o.focalLength ? 1 : -1;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/camerax/utils/SingleThreadHandlerExecutor.java b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/utils/SingleThreadHandlerExecutor.java
new file mode 100644
index 000000000..09a4ce948
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/camerax/utils/SingleThreadHandlerExecutor.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.quark.quamera.camerax.utils;
+
+import android.os.Handler;
+import android.os.HandlerThread;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.RejectedExecutionException;
+
+import androidx.annotation.NonNull;
+
+public final class SingleThreadHandlerExecutor implements Executor {
+
+ private final String mThreadName;
+ private final HandlerThread mHandlerThread;
+ private final Handler mHandler;
+
+ public SingleThreadHandlerExecutor(@NonNull String threadName, int priority) {
+ this.mThreadName = threadName;
+ mHandlerThread = new HandlerThread(threadName, priority);
+ mHandlerThread.start();
+ mHandler = new Handler(mHandlerThread.getLooper());
+ }
+
+ @NonNull
+ public Handler getHandler() {
+ return mHandler;
+ }
+
+ @Override
+ public void execute(@NonNull Runnable command) {
+ if (!mHandler.post(command)) {
+ throw new RejectedExecutionException(mThreadName + " is shutting down.");
+ }
+ }
+
+ public boolean shutdown() {
+ return mHandlerThread.quitSafely();
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/CameraVideoRenderExecutor.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/CameraVideoRenderExecutor.java
new file mode 100644
index 000000000..86553a714
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/CameraVideoRenderExecutor.java
@@ -0,0 +1,27 @@
+package com.quark.quamera.render;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/4/13
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import com.quark.quamera.render.view.AndroidGLSurfaceView;
+
+import java.util.concurrent.Executor;
+
+public class CameraVideoRenderExecutor implements Executor {
+
+ private AndroidGLSurfaceView mGLSurfaceView;
+
+ public CameraVideoRenderExecutor(AndroidGLSurfaceView GLSurfaceView) {
+ mGLSurfaceView = GLSurfaceView;
+ }
+
+
+ @Override
+ public void execute(Runnable command) {
+ mGLSurfaceView.queueEvent(command);
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/CameraVideoRenderPipe.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/CameraVideoRenderPipe.java
new file mode 100644
index 000000000..c482593d5
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/CameraVideoRenderPipe.java
@@ -0,0 +1,611 @@
+package com.quark.quamera.render;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.RectF;
+import android.opengl.EGL14;
+import android.opengl.GLES11Ext;
+import android.opengl.GLES20;
+import android.os.Build;
+import android.os.SystemClock;
+import android.util.Log;
+import android.util.Rational;
+
+import com.quark.quamera.camera.preview.ViewPort;
+import com.quark.quamera.render.entry.FrameDetectData;
+import com.quark.quamera.render.entry.RenderFlowData;
+import com.quark.quamera.render.expansion.IRenderExpansion;
+import com.quark.quamera.render.photo.ExportPhoto;
+import com.quark.quamera.render.photo.SnapShotCommand;
+import com.quark.quamera.render.view.AndroidGLSurfaceView;
+import com.quark.quamera.util.CameraInit;
+import com.quark.quamera.util.CameraLogger;
+import com.quark.quamera.util.CameraShould;
+import com.quark.quamera.util.ImageUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.RejectedExecutionException;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+
+import androidx.annotation.FloatRange;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+/**
+ * 渲染到屏幕，并且进行录制
+ */
+@TargetApi(18)
+public class CameraVideoRenderPipe implements AndroidGLSurfaceView.Renderer, ICameraRender.ICameraFrameAvailableListener {
+
+ private static final String TAG = "CameraVideoRender";
+
+ private ScreenRenderFilter mScreenRender;//绘制到屏幕
+
+ private GlFboFilter mCameraFilter;//直接从外部纹理绘制内容到FBO
+
+ private @ViewPort.ScaleType
+ int mCameraScaleType = ViewPort.FILL_CENTER;
+
+ private CropFboFilter mCropFboFilter;
+
+ private CropFboFilter mTransformFilter;
+
+ @Deprecated
+ //后续用mCameraShowRect来代替
+ private Rational mCameraShowRational;
+
+ private ICameraShowViewChangeListener mLayoutChangeListener;
+
+ private volatile boolean mLayoutChange = false;
+
+ private IRenderExpansion mRenderExpansion;
+
+ private boolean mHasRelease = false;
+
+
+ private final RectF mTempRectF = new RectF();
+ private final RectF mCameraShowRect = new RectF();
+
+ private int mSurfaceTextureId = -1;
+ private int mWindowWidth;
+ private int mWindowHeight;
+
+ private final Context mContext;
+ private SnapShotCommand mSnapShotCommand;
+ private final AndroidGLSurfaceView mHost;
+
+ public CameraVideoRenderPipe(@NonNull Context context,
+ @NonNull AndroidGLSurfaceView host,
+ @NonNull IRenderExpansion expansion) {
+ mContext = context;
+ mHost = host;
+ mRenderExpansion = expansion;
+ }
+
+ public void setCameraShowLayoutChangeListener(ICameraShowViewChangeListener layoutChangeListener) {
+ mLayoutChangeListener = layoutChangeListener;
+ }
+
+
+ public void snapshot(final SnapShotCommand snapShotCommand) {
+ mSnapShotCommand = snapShotCommand;
+ }
+
+ @Override
+ public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+ initSurfaceTexture();
+
+ CameraLogger.i("CameraVideoView", "on surfaceCreated");
+
+ if (mScreenRender == null) {
+ mScreenRender = new ScreenRenderFilter();
+ mScreenRender.setScaleType();
+ mScreenRender.prepare();
+ }
+
+ if (mCropFboFilter == null) {
+ mCropFboFilter = new CropFboFilter();
+ }
+
+ if (mTransformFilter == null) {
+ mTransformFilter = new CropFboFilter();
+ }
+
+ if (mRenderExpansion != null) {
+ mRenderExpansion.onSurfaceCreated(gl, config);
+ }
+ }
+
+ @Override
+ public void onSurfaceChanged(GL10 gl, int width, int height) {
+ CameraLogger.i(GLConstant.TAG, "Render surface changed width=" + width + ", height=" + height + " GLContext " + EGL14.eglGetCurrentContext());
+
+
+ if (mWindowWidth != width || mWindowHeight != height) {
+ mLayoutChange = true;
+ }
+
+ mWindowWidth = width;
+ mWindowHeight = height;
+
+ if (mCameraShowRect.isEmpty()) {
+ mCameraShowRect.set(0, 0, mWindowWidth, mWindowHeight);
+ }
+
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+ calculateCameraShowRational();
+ }
+
+ if (mRenderExpansion != null) {
+ mRenderExpansion.onSurfaceChanged(gl, width, height);
+ }
+ }
+
+
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ private void calculateCameraShowRational() {
+ if (mWindowHeight != 0 && mWindowWidth != 0) {
+ float heightPercentage = 1 - mMarginPercentage[1] - mMarginPercentage[3];
+ switch (mCameraScaleType) {
+ case ViewPort.FILL_CENTER:
+ mCameraShowRational = new Rational(mWindowWidth, (int) (mWindowHeight * heightPercentage));
+ break;
+ case ViewPort.CENTER_INSIDE:
+ //没有相机的时候，直接提供屏幕的宽高比
+ if (mCameraSurfaceRender == null) {
+ mCameraShowRational = new Rational(mWindowWidth, (int) (mWindowHeight * heightPercentage));
+ return;
+ }
+ int[] size = mCameraSurfaceRender.getCameraCaptureSize();
+ if (mCameraSurfaceRender.isMatrixInverseWidthHeight()) {
+ mCameraShowRational = new Rational(size[1], size[0]);
+ } else {
+ mCameraShowRational = new Rational(size[0], size[1]);
+ }
+ break;
+ default:
+ CameraShould.fail("not support now");
+ }
+
+ }
+
+ }
+
+ public Rational getCameraShowRational() {
+ return mCameraShowRational;
+ }
+
+ public int getWindowWidth() {
+ return mWindowWidth;
+ }
+
+ public int getWindowHeight() {
+ return mWindowHeight;
+ }
+
+ public void setWindowHeight(int windowHeight) {
+ mWindowHeight = windowHeight;
+ }
+
+ public void onSurfaceDestroy() {
+ CameraLogger.i("CameraVideoView", "onSurfaceDestroy");
+
+ mCameraShowRect.setEmpty();
+
+
+ if (mRenderExpansion != null) {
+ mRenderExpansion.onSurfaceDestroy();
+ mRenderExpansion = null;
+ }
+
+ //退出的时候，确保所有任务都可以执行到（此处先忽略锁）,
+ // 顺序放在RenderExpansion后面，因为其他为内部释放，不会触发Task
+ //TODO 不能继续执行task任务，因为这些任务可能依赖GL环境，但是destory的时候，GL环境是不稳定的，目前GL Surface方案无法保证声明周期可控
+// while (mTasks.size() > 0) {
+// runExecutorTask();
+// }
+ synchronized (mTasks) {
+ mTasks.clear();
+ }
+
+ mHasRelease = true;
+
+ if (mCameraFilter != null) {
+ mCameraFilter.release();
+ mCameraFilter = null;
+ }
+
+ if (mCropFboFilter != null) {
+ mCropFboFilter.release();
+ mCropFboFilter = null;
+ }
+
+ if (mTransformFilter != null) {
+ mTransformFilter.release();
+ mTransformFilter = null;
+ }
+
+ if (mScreenRender != null) {
+ mScreenRender.release();
+ mScreenRender = null;
+ }
+
+
+ }
+
+
+ private void createCameraRenderFBOIfNeed() {
+ int[] size = mCameraSurfaceRender.getCameraCaptureSize();
+
+ int outWith = size[0];
+ int outHeight = size[1];
+ if (mCameraSurfaceRender.isMatrixInverseWidthHeight()) {
+ outWith = size[1];
+ outHeight = size[0];
+ }
+ if (mCameraFilter != null
+ //size not change
+ && (mCameraFilter.getOutputHeight() == outHeight
+ && mCameraFilter.getOutputWidth() == outWith)) {
+ return;
+ }
+ mCameraFilter = new GlFboFilter();
+ mCameraFilter.setInputTextureId(mSurfaceTextureId);
+ mCameraFilter.setInputSize(size[0], size[1]);
+ mCameraFilter.setOutputSize(outWith, outHeight);
+ mCameraFilter.prepare();
+ }
+
+ private void runExecutorTask() {
+ try {
+ List tasks;
+ synchronized (mTasks) {
+ tasks = new ArrayList<>(mTasks);
+ mTasks.clear();
+ }
+
+ for (Runnable task : tasks) {
+ task.run();
+ }
+ } catch (Exception ignore) {
+ }
+ }
+
+ @Override
+ public void onDrawFrame(GL10 gl) {
+ runExecutorTask();
+
+ SnapShotCommand tempSnapshotCommand;
+
+ //局部持有callback，避免没有使用的call 在 draw完后直接给清空了
+ synchronized (CameraVideoRenderPipe.this) {
+ tempSnapshotCommand = mSnapShotCommand;
+ }
+
+ try {
+ renderInner(tempSnapshotCommand);
+ } finally {
+ if (tempSnapshotCommand != null) {
+ synchronized (CameraVideoRenderPipe.this) {
+ if (tempSnapshotCommand == mSnapShotCommand) {
+ mSnapShotCommand = null;
+ }
+ }
+ }
+ }
+ }
+
+ private final List mTasks = new ArrayList<>();
+
+
+ public boolean queueTask(Runnable runnable) {
+ if (mHasRelease) {
+ throw new RejectedExecutionException("gl render thread has shutdown");
+ }
+ synchronized (mTasks) {
+ mTasks.add(runnable);
+ }
+ return true;
+ }
+
+
+ private long mFpsCount;
+ private long mResetRecordFpsTime = 0;
+
+
+ //left top right bottom (margin)
+ private final float[] mMarginPercentage = new float[4];
+
+ public void setCameraShowRect(@FloatRange(from = 0.0, to = 1.0) float topMargin, @FloatRange(from = 0.0, to = 1.0) float bottomMargin) {
+ if (mMarginPercentage[1] != topMargin || mMarginPercentage[3] != bottomMargin) {
+ mLayoutChange = true;
+ }
+ mMarginPercentage[1] = topMargin;
+ mMarginPercentage[3] = bottomMargin;
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+ calculateCameraShowRational();
+ }
+ requestRenderIfNeed();
+ }
+
+
+ private void requestRenderIfNeed() {
+ if (mHost.getRenderMode() == AndroidGLSurfaceView.RENDERMODE_CONTINUOUSLY) {
+ return;
+ }
+ if (mLayoutChange) {
+ mLayoutChange = false;
+ mHost.requestRender();
+ }
+ }
+
+
+ private float getHeightPercentage() {
+ return 1 - mMarginPercentage[1] - mMarginPercentage[3];
+ }
+
+ @NonNull
+ public float[] getMarginPercentage() {
+ return mMarginPercentage;
+ }
+
+ //TODO 后续需要实现显存服用(Texture的服用)
+ private void renderInner(SnapShotCommand snapShotCommand) {
+ //因为View的创建渲染早于camera打开，所以使用新的时间戳来作为整体时间戳，而不是使用相机
+ long timestamp = SystemClock.uptimeMillis();
+
+ long start = SystemClock.elapsedRealtimeNanos();
+
+ GLES20.glEnable(GLES20.GL_BLEND);
+ GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA);
+
+
+ RenderFlowData data = RenderFlowData.obtain(mWindowWidth, mWindowHeight, null);
+
+ long step1 = SystemClock.elapsedRealtimeNanos();
+ if (mCameraSurfaceRender != null && mCameraSurfaceRender.needRender()) {
+ //更新相机纹理
+ mCameraSurfaceRender.update(EGL14.eglGetCurrentContext(), mSurfaceTextureId, data.extraData);
+
+ createCameraRenderFBOIfNeed();
+ mCameraFilter.draw(mCameraSurfaceRender.getOESMatrix());
+ data.textureWidth = mCameraFilter.getOutputWidth();
+ data.textureHeight = mCameraFilter.getOutputHeight();
+ data.texture = mCameraFilter.getOutputTextureId();
+ }
+
+ step1 = SystemClock.elapsedRealtimeNanos() - step1;
+
+ long step2 = SystemClock.elapsedRealtimeNanos();
+
+ RenderFlowData snapshotData = null;
+
+ if (mCropFboFilter != null && data.texture != -1) {
+
+ int outHeight = (int) (mWindowHeight * getHeightPercentage());
+ //宽度发生了改变
+ if (mCropFboFilter.isPrepared()) {
+ if (mCropFboFilter.getOutputHeight() != outHeight) {
+ mCropFboFilter.release();
+ mCropFboFilter = new CropFboFilter();
+ }
+ }
+ mCropFboFilter.setOutputSize(data.windowWidth, outHeight);
+ mCropFboFilter.setInputTextureId(data.texture);
+ mCropFboFilter.setInputSize(data.textureWidth, data.textureHeight);
+ // input为相机预览的分辨率 out为输出展示的宽高 矩阵缩放
+ ImageUtils.getScaleVertexMatrix(mCameraScaleType, mCropFboFilter.getPosMtx(),
+ mCropFboFilter.getInputWidth(), mCropFboFilter.getInputHeight(),
+ mCropFboFilter.getOutputWidth(), mCropFboFilter.getOutputHeight());
+ mCropFboFilter.prepare();
+ mCropFboFilter.draw(null);
+
+ data = RenderFlowData.obtain(data.windowWidth, data.windowHeight, data.extraData);
+ data.textureWidth = mCropFboFilter.getOutputWidth();
+ data.textureHeight = mCropFboFilter.getOutputHeight();
+ data.texture = mCropFboFilter.getOutputTextureId();
+
+ snapshotData = data;
+ if (mTransformFilter != null) {
+ mTransformFilter.setOutputSize(data.windowWidth, mWindowHeight);
+ mTransformFilter.setInputTextureId(data.texture);
+ mTransformFilter.setInputSize(data.textureWidth, data.textureHeight);
+ ImageUtils.getClipVertexMatrix(mTransformFilter.getPosMtx(), mMarginPercentage);
+ mTransformFilter.prepare();
+ mTransformFilter.draw(null);
+
+ data = RenderFlowData.obtain(data.windowWidth, data.windowHeight, data.extraData);
+ data.textureWidth = mTransformFilter.getOutputWidth();
+ data.textureHeight = mTransformFilter.getOutputHeight();
+ data.texture = mTransformFilter.getOutputTextureId();
+ }
+
+ calculateCameraShowLayout();
+ }
+
+ if (snapshotData == null) {
+ snapshotData = data;
+ }
+
+
+ step2 = SystemClock.elapsedRealtimeNanos() - step2;
+
+ long step3 = SystemClock.elapsedRealtimeNanos();
+
+ if (mRenderExpansion != null && data.texture != -1) {
+ data = mRenderExpansion.render(data, timestamp);
+ }
+
+ step3 = SystemClock.elapsedRealtimeNanos() - step3;
+
+ long step4 = SystemClock.elapsedRealtimeNanos();
+
+
+ if (snapShotCommand != null) {
+ SnapshotFilter snapshotFilter = new SnapshotFilter();
+ snapshotFilter.setInputSize(snapshotData.textureWidth, snapshotData.textureHeight);
+ snapshotFilter.setInputTextureId(snapshotData.texture);
+ snapshotFilter.prepare();
+ Bitmap result = snapshotFilter.snapshot(snapShotCommand);
+ snapshotFilter.release();
+
+ FrameDetectData detectData = data.detectData;
+
+
+ ExportPhoto mainExport = ExportPhoto.ofBitmap(result);
+
+ if (mainExport != null) {
+ mainExport.setHasClip(snapShotCommand.needClip())
+ .setFrameDetectData(detectData)
+ .setSnapShotCommand(snapShotCommand);
+
+ for (SnapShotCommand command : snapShotCommand.getSubCommand()) {
+
+ long startTimes = SystemClock.uptimeMillis();
+ int outWidth = (int) (command.getScale() * snapshotData.textureWidth);
+ int outHeight = (int) (command.getScale() * snapshotData.textureHeight);
+ SnapshotFilter subFilter = new SnapshotFilter();
+ subFilter.setInputSize(snapshotData.textureWidth, snapshotData.textureHeight);
+ subFilter.setInputTextureId(snapshotData.texture);
+ subFilter.setOutputSize(outWidth, outHeight);
+ subFilter.prepare();
+
+ Bitmap subBitmap = subFilter.snapshot(snapShotCommand);
+ ExportPhoto subPhoto = ExportPhoto.ofBitmap(subBitmap)
+ .setHasClip(command.needClip())
+ .setSnapShotCommand(command);
+ subFilter.release();
+ mainExport.addSubPhoto(subPhoto);
+
+ if (CameraInit.getConfig().isDebuggable()) {
+ Log.i(TAG, String.format("snapshot sub image (%d, %d) use times %d ", outWidth, outHeight, (SystemClock.uptimeMillis() - startTimes)));
+ }
+ }
+ }
+
+ try {
+ if (snapShotCommand.getCallback() != null) {
+ snapShotCommand.getCallback().onReceiveValue(mainExport);
+ }
+ } catch (Exception e) {
+ CameraShould.fail("", e);
+ }
+ }
+
+
+ if (mScreenRender != null) {
+ mScreenRender.setInputSize(data.textureWidth, data.textureHeight);
+ mScreenRender.setInputTextureId(data.texture);
+ mScreenRender.setViewPort(mWindowWidth, mWindowHeight);
+ mScreenRender.draw();
+ }
+
+ if (CameraInit.getConfig().isDebuggable()) {
+ step4 = SystemClock.elapsedRealtimeNanos() - step4;
+
+ if (SystemClock.uptimeMillis() - mResetRecordFpsTime > 1000) {
+ Log.i(TAG, "camera video view fps:" + mFpsCount);
+ mFpsCount = 0;
+ mResetRecordFpsTime = SystemClock.uptimeMillis();
+ } else {
+ mFpsCount++;
+ }
+
+ Log.i(TAG, String.format(Locale.CHINA, "draw use time : %.3f (1: %.3f , 2:%.3f, 3:%.3f , 4:%.3f) ",
+ (float) (SystemClock.elapsedRealtimeNanos() - start) / 1000000, (float) step1 / 1000000, (float) step2 / 1000000, (float) step3 / 1000000, (float) step4 / 1000000)
+ );
+ }
+
+ }
+
+ private void calculateCameraShowLayout() {
+ if (mCameraSurfaceRender == null) {
+ return;
+ }
+ mTempRectF.setEmpty();
+
+ switch (mCameraScaleType) {
+ case ViewPort.CENTER_INSIDE:
+ //CameraShould.fail("not support now");
+ break;
+ case ViewPort.FILL_CENTER:
+ mTempRectF.set(mMarginPercentage[0] * mWindowWidth,
+ mMarginPercentage[1] * mWindowHeight,
+ (1 - mMarginPercentage[2]) * mWindowWidth,
+ (1 - mMarginPercentage[3]) * mWindowHeight
+ );
+ break;
+ default:
+ CameraShould.fail("not support now");
+ break;
+ }
+
+ if (mLayoutChangeListener != null && !mCameraShowRect.equals(mTempRectF)) {
+ mCameraShowRect.set(mTempRectF);
+ mLayoutChangeListener.onCameraShowLayoutChanged(mTempRectF.left, mTempRectF.top, mTempRectF.width(),
+ mTempRectF.height());
+ mTempRectF.setEmpty();
+ }
+ }
+
+ public RectF getCameraShowRect() {
+ return mCameraShowRect;
+ }
+
+
+ private ICameraRender mCameraSurfaceRender;
+
+
+ public void setCameraRender(ICameraRender cameraRender) {
+ mCameraSurfaceRender = cameraRender;
+ if (mCameraSurfaceRender != null) {
+ mCameraSurfaceRender.setCameraFrameAvailableListener(this);
+ }
+ }
+
+
+ private void initSurfaceTexture() {
+ int[] textures = new int[1];
+ GLES20.glGenTextures(1, textures, 0);
+ mSurfaceTextureId = textures[0];
+
+ GLES20.glDisable(GLES20.GL_DEPTH_TEST);
+ GLES20.glDisable(GLES20.GL_CULL_FACE);
+ GLES20.glDisable(GLES20.GL_BLEND);
+ GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+ GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, mSurfaceTextureId);
+ 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);
+
+ }
+
+
+ public void setCameraScaleType(int cameraScaleType) {
+ if (mCameraScaleType != cameraScaleType) {
+ mLayoutChange = true;
+ }
+ mCameraScaleType = cameraScaleType;
+ requestRenderIfNeed();
+ }
+
+ public int getCameraScaleType() {
+ return mCameraScaleType;
+ }
+
+ @Override
+ public void onCameraFrameAvailable() {
+ mHost.requestRender();
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/CropFboFilter.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/CropFboFilter.java
new file mode 100644
index 000000000..8c14b6830
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/CropFboFilter.java
@@ -0,0 +1,349 @@
+package com.quark.quamera.render;
+
+import android.annotation.TargetApi;
+import android.graphics.Bitmap;
+import android.opengl.GLES11Ext;
+import android.opengl.GLES20;
+import android.opengl.Matrix;
+import android.util.Log;
+
+import com.quark.quamera.util.GlCommonUtil;
+import com.quark.quamera.util.MatrixUtils;
+import com.quark.quamera.util.OpenGlUtils;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+import java.util.LinkedList;
+
+
+@TargetApi(18)
+//TODO 后面将filter相同内容抽象成基类
+public class CropFboFilter {
+
+ private final FloatBuffer mVtxBuf = OpenGlUtils.createSquareVtx();
+ protected float[] mPosMtx = OpenGlUtils.createIdentityMtx();
+ private float[] mNormalPosMtx = OpenGlUtils.createIdentityMtx();
+ private float[] mIdentityMtx = OpenGlUtils.createIdentityMtx();
+ private float[] mFlipXPosMtx = MatrixUtils.flipF(OpenGlUtils.createIdentityMtx(), true, false);
+ private final float[] mFlipYPosMtx = MatrixUtils.flipF(OpenGlUtils.createIdentityMtx(), false, true);
+
+ protected int mInputTextureId = -1;
+ private int mProgram = -1;
+ private int maPositionHandle = -1;
+ private int maTexCoordHandle = -1;
+ private int muPosMtxHandle = -1;
+ private int muTexMtxHandle = -1;
+
+ private final int[] mTexId = new int[]{0};
+
+ private int mFboId = -1;
+
+ protected int mInputWidth = -1;
+ protected int mInputHeight = -1;
+
+ protected int mOutputWidth = -1;
+ protected int mOutputHeight = -1;
+
+ private boolean mIsExternalOES;//是否从外部纹理读取数据
+
+ private final LinkedList mRunOnDraw;
+ private String mVertex;
+ private String mFragment;
+
+ private int mX = 0;
+ private int mY = 0;
+ private boolean mNeedClear = true;
+
+ //TODO only for test code，always false when commit
+ boolean mDoSnapshot = false;
+
+ private boolean mPrepared = false;
+
+
+ public CropFboFilter() {
+ this(false);
+ }
+
+ public CropFboFilter(boolean isExternalOES) {
+ mIsExternalOES = isExternalOES;
+ mRunOnDraw = new LinkedList<>();
+ if (isExternalOES) {
+ mVertex = GLConstant.SHADER_DEFAULT_VERTEX;
+ mFragment = GLConstant.SHADER_DEFAULT_FRAGMENT_OES;
+ } else {
+ mVertex = GLConstant.SHADER_DEFAULT_VERTEX;
+ mFragment = GLConstant.SHADER_DEFAULT_FRAGMENT_NOT_OES;
+ }
+ }
+
+ public void normalPosMtx() {
+ mPosMtx = mNormalPosMtx;
+ }
+
+ public void flipPosMtxX() {
+ mPosMtx = mFlipXPosMtx;
+ }
+
+ public void flipPosMtxY() {
+ mPosMtx = mFlipYPosMtx;
+ }
+
+ public float[] getPosMtx() {
+ return mPosMtx;
+ }
+
+ public void setInputSize(int width, int height) {
+ mInputWidth = width;
+ mInputHeight = height;
+ }
+
+
+ public void setOutputSize(int width, int height) {
+ mOutputWidth = width;
+ mOutputHeight = height;
+ }
+
+ public int getOutputWidth() {
+ return mOutputWidth;
+ }
+
+ public int getOutputHeight() {
+ return mOutputHeight;
+ }
+
+ public void setNeedClear(boolean need) {
+ mNeedClear = need;
+ }
+
+ public void clear() {
+ GLES20.glClearColor(0f, 0f, 0f, 1f);
+ GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
+ }
+
+ public void prepare() {
+ if (mPrepared) {
+ return;
+ }
+ loadShaderAndParams(mVertex, mFragment);
+ createEffectTexture();
+ mPrepared = true;
+ }
+
+ public boolean isPrepared() {
+ return mPrepared;
+ }
+
+
+ public void setInputTextureId(int textureId) {
+ mInputTextureId = textureId;
+ }
+
+ private void loadShaderAndParams(String vertex, String fragment) {
+ GlCommonUtil.checkGlError("initSH_S");
+ mProgram = GlCommonUtil.createProgram(vertex, fragment);
+ maPositionHandle = GLES20.glGetAttribLocation(mProgram, "position");
+ maTexCoordHandle = GLES20.glGetAttribLocation(mProgram, "inputTextureCoordinate");
+ muPosMtxHandle = GLES20.glGetUniformLocation(mProgram, "uPosMtx");
+ muTexMtxHandle = GLES20.glGetUniformLocation(mProgram, "uTexMtx");
+ GlCommonUtil.checkGlError("initSH_E");
+ }
+
+ public int getInputWidth() {
+ return mInputWidth;
+ }
+
+ public int getInputHeight() {
+ return mInputHeight;
+ }
+
+ private void createEffectTexture() {
+ if (mOutputWidth <= 0 || mOutputHeight <= 0) {
+ return;
+ }
+ GlCommonUtil.checkGlError("initFBO_S");
+ createFrameBuffer();
+ GLES20.glGenTextures(1, mTexId, 0);
+
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mFboId);
+
+ GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTexId[0]);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
+
+ GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA,
+ mOutputWidth, mOutputHeight, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);
+
+ GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER,
+ GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, mTexId[0], 0);
+
+ if (GLES20.glCheckFramebufferStatus(GLES20.GL_FRAMEBUFFER) !=
+ GLES20.GL_FRAMEBUFFER_COMPLETE) {
+ throw new RuntimeException("glCheckFramebufferStatus()");
+ }
+ GlCommonUtil.checkGlError("initFBO_E");
+ }
+
+
+ public int getOutputTextureId() {
+ return mTexId[0];
+ }
+
+ protected void runOnDraw(final Runnable runnable) {
+ synchronized (mRunOnDraw) {
+ mRunOnDraw.addLast(runnable);
+ }
+ }
+
+ protected void runPendingOnDrawTasks() {
+ while (!mRunOnDraw.isEmpty()) {
+ mRunOnDraw.removeFirst().run();
+ }
+ }
+
+ public void draw(float[] tex_mtx) {
+ if (tex_mtx == null) {
+ tex_mtx = mIdentityMtx;
+ }
+ draw(tex_mtx, mPosMtx);
+ }
+
+ public void draw(float[] tex_mtx, final float[] posMatrix) {
+ if (-1 == mProgram || mInputTextureId == -1 || mInputWidth == -1) {
+ return;
+ }
+
+ GlCommonUtil.checkGlError("draw_S");
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mFboId);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ GLES20.glViewport(mX, mY, mOutputWidth, mOutputHeight);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ if (mNeedClear) {
+ GLES20.glClearColor(0f, 0f, 0f, 1f);
+ GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
+ }
+ GLES20.glUseProgram(mProgram);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ runPendingOnDrawTasks();
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ mVtxBuf.position(0);
+ GLES20.glVertexAttribPointer(maPositionHandle,
+ 3, GLES20.GL_FLOAT, false, 4 * (3 + 2), mVtxBuf);
+ GLES20.glEnableVertexAttribArray(maPositionHandle);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ mVtxBuf.position(3);
+ GLES20.glVertexAttribPointer(maTexCoordHandle,
+ 2, GLES20.GL_FLOAT, false, 4 * (3 + 2), mVtxBuf);
+ GLES20.glEnableVertexAttribArray(maTexCoordHandle);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ if (muPosMtxHandle >= 0) {
+ GLES20.glUniformMatrix4fv(muPosMtxHandle, 1, false, posMatrix, 0);
+ }
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ if (muTexMtxHandle >= 0) {
+ GLES20.glUniformMatrix4fv(muTexMtxHandle, 1, false, tex_mtx, 0);
+ }
+
+ GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+ if (mIsExternalOES) {
+ GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, mInputTextureId);
+ } else {
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mInputTextureId);
+ }
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
+
+ //only for test code
+ if (mDoSnapshot) {
+ Bitmap result = doSnapshot(mOutputWidth, mOutputHeight);
+ Log.e("SnapShotTest", "test " + result.getHeight());
+ }
+
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ GLES20.glDisableVertexAttribArray(maPositionHandle);
+ GLES20.glDisableVertexAttribArray(maTexCoordHandle);
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+
+ if (mIsExternalOES) {
+ GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, 0);
+ } else {
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+ }
+ GLES20.glUseProgram(0);
+
+ GlCommonUtil.checkGlError("draw_E");
+ }
+
+ public static Bitmap doSnapshot(int width, int height) {
+ final ByteBuffer rgbaData = ByteBuffer.allocateDirect(width * height * 4);
+ rgbaData.order(ByteOrder.nativeOrder());
+
+ GLES20.glReadPixels(0, 0, width, height, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE,
+ rgbaData);
+
+ Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+ bitmap.copyPixelsFromBuffer(rgbaData);
+
+ return bitmap;
+ }
+
+
+ private void createFrameBuffer() {
+ int[] fboId = new int[]{0};
+ GLES20.glGenFramebuffers(1, fboId, 0);
+ mFboId = fboId[0];
+ Log.d("e", "createFrameBuffer: ");
+ }
+
+ private void releaseFrameBuffer() {
+ if (mFboId != -1) {
+ int[] fboId = new int[]{mFboId};
+ GLES20.glDeleteFramebuffers(1, fboId, 0);
+ mFboId = -1;
+ }
+ }
+
+ private void releaseProgram() {
+ if (mProgram == -1) {
+ return;
+ }
+ GLES20.glDeleteProgram(mProgram);
+ }
+
+ public void release() {
+ releaseTexture();
+ releaseFrameBuffer();
+ releaseProgram();
+ }
+
+ public void releaseTexture() {
+ if (mTexId[0] > 0) {
+ GlCommonUtil.deleteGLTexture(mTexId);
+ }
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/DefaultCameraRender.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/DefaultCameraRender.java
new file mode 100644
index 000000000..22d10fdb1
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/DefaultCameraRender.java
@@ -0,0 +1,269 @@
+package com.quark.quamera.render;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/1/26
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.opengl.EGLContext;
+import android.os.Build;
+import android.os.SystemClock;
+import android.util.Log;
+
+import com.quark.quamera.camera.camera.Camera2CameraImpl;
+import com.quark.quamera.camera.camera.CameraState;
+import com.quark.quamera.camera.camera.ICameraStateListener;
+import com.quark.quamera.camera.preview.SurfaceTextureWrapper;
+import com.quark.quamera.camera.session.CameraCaptureCallback;
+import com.quark.quamera.camera.session.CameraCaptureComboCallback;
+import com.quark.quamera.camera.session.CameraCaptureResult;
+import com.quark.quamera.camerax.utils.CameraXCaptureResultManager;
+import com.quark.quamera.util.Camera2CaptureResultManager;
+import com.quark.quamera.util.CameraInit;
+import com.quark.quamera.util.CameraShould;
+
+import java.util.Map;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.camera.camera2.internal.Camera2CameraCaptureResult;
+
+
+public class DefaultCameraRender implements ICameraRender, ICameraStateListener {
+
+ public SurfaceTextureWrapper mSurfaceTextureWrapper;
+ private final float[] mOESMatrix = new float[16];
+
+
+ public static final String TAG = "CameraRender";
+
+ private long mLastUpdateTime = -1;
+ private long mLastFPSTime = 0;
+ private long mFPSCount = 0;
+
+
+ private volatile boolean mReceiveFirstFrame = false;
+ private volatile boolean mHasNewFrame = false;
+
+ private ICameraFrameAvailableListener mAvailableListener;
+
+ private final Camera2CameraImpl mCamera;
+
+
+ private final CameraCaptureCallback mCaptureCallback = new CameraCaptureCallback() {
+ @Override
+ public void onCaptureCompleted(@NonNull CameraCaptureResult cameraCaptureResult) {
+ super.onCaptureCompleted(cameraCaptureResult);
+ mMemManager.cacheCaptureResult(cameraCaptureResult);
+ }
+ };
+
+ private final Object mResultLock = new Object();
+
+ private CameraCaptureResult mCurrentCaptureResult;
+ private Camera2CameraCaptureResult mCameraXCurrentCaptureResult;
+
+ private final CameraCaptureComboCallback mComboCallback;
+
+ private final Camera2CaptureResultManager mMemManager;
+ private final CameraXCaptureResultManager mReleaseManager;
+
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ public DefaultCameraRender(@NonNull SurfaceTextureWrapper surfaceTextureWrapper, Camera2CameraImpl camera,
+ CameraCaptureComboCallback captureCallback) {
+ mSurfaceTextureWrapper = surfaceTextureWrapper;
+ mCamera = camera;
+
+ mComboCallback = captureCallback;
+ if (mComboCallback != null) {
+ mComboCallback.addCallback(mCaptureCallback);
+ }
+ mMemManager = new Camera2CaptureResultManager();
+ mReleaseManager = new CameraXCaptureResultManager();
+
+ if (mCamera != null) {
+ mCamera.getCameraStateImmediatelyObservable().addListener(this);
+ }
+
+ surfaceTextureWrapper.getSurfaceTexture().setOnFrameAvailableListener(surfaceTexture -> {
+
+ long surfaceTimeStamp = surfaceTextureWrapper.getSurfaceTexture().getTimestamp();
+
+ if (CameraInit.getConfig().isDebuggable()) {
+ Log.d(TAG, "CameraCaptureCallback.onCaptureCompleted setOnFrameAvailableListener -- " + surfaceTimeStamp);
+ }
+
+ mReceiveFirstFrame = true;
+ synchronized (DefaultCameraRender.this) {
+ mHasNewFrame = true;
+ }
+
+ CameraCaptureResult captureResult = mMemManager.consumeMatchCaptureResult(surfaceTimeStamp);
+ // 对于CameraX的处理，内存释放
+ Camera2CameraCaptureResult cameraXCaptureResult = mReleaseManager.consumeMatchCaptureResult(surfaceTimeStamp);
+
+ synchronized (mResultLock) {
+ /*
+ * 释放上一帧的数据，立即释放，而不是等待GC
+ */
+ mMemManager.releaseCaptureResultNow(mCurrentCaptureResult);
+
+ mCurrentCaptureResult = captureResult;
+
+ mReleaseManager.releaseCaptureResultNow(mCameraXCurrentCaptureResult);
+ mCameraXCurrentCaptureResult = cameraXCaptureResult;
+ }
+
+ if (mAvailableListener != null) {
+ mAvailableListener.onCameraFrameAvailable();
+ }
+ });
+ }
+
+
+ @Override
+ public boolean update(EGLContext context, int textureId, Map cameraInfo) {
+ if (!mSurfaceTextureWrapper.isValid()) {
+ return false;
+ }
+ boolean hasNewFrame;
+
+ synchronized (DefaultCameraRender.this) {
+ hasNewFrame = mHasNewFrame;
+ mHasNewFrame = false;
+ }
+
+ if (CameraInit.getConfig().isDebuggable()) {
+ long currentTime = SystemClock.uptimeMillis();
+ long useTime = currentTime - mLastUpdateTime;
+
+ if (currentTime - mLastFPSTime > 1000) {
+ Log.i(TAG, "FPS:" + mFPSCount);
+ mFPSCount = 1;
+ mLastFPSTime = currentTime;
+ } else {
+ mFPSCount++;
+ }
+ mLastUpdateTime = SystemClock.uptimeMillis();
+ Log.i(TAG, "frame:" + useTime);
+ }
+
+
+ boolean attachSuccess = mSurfaceTextureWrapper.attachToGLContext(context.hashCode(), textureId);
+ try {
+ if (attachSuccess) {
+ try {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+ if (mCamera != null) {
+ cameraInfo.put("device_rotation",
+ mCamera.getCamera2Info().getImageRotationHelper().getDeviceRotation());
+ cameraInfo.put("camera_sensor_rotation",
+ mCamera.getCamera2Info().getImageRotationHelper().getCameraSensorOrientation());
+
+ }
+ synchronized (mResultLock) {
+ // if (mCurrentCaptureResult != null) {
+ // cameraInfo.put("af_state", mCurrentCaptureResult.getAfState());
+ // cameraInfo.put("af_mode", mCurrentCaptureResult.getAfMode());
+ // }
+ }
+ }
+ } catch (Exception ignore) {
+ }
+
+ mSurfaceTextureWrapper.updateTexImage();
+ }
+ } catch (Exception e) {
+ CameraShould.fail("Surface.updateTexImage Error", e);
+ }
+
+ return hasNewFrame;
+ }
+
+
+ @Override
+ public boolean needRender() {
+ return mReceiveFirstFrame && mSurfaceTextureWrapper.isValid();
+ }
+
+ @Override
+ public void setCameraFrameAvailableListener(ICameraFrameAvailableListener listener) {
+ mAvailableListener = listener;
+ }
+
+ @Override
+ public int[] getCameraCaptureSize() {
+ return mSurfaceTextureWrapper.getSize();
+ }
+
+ @Override
+ public float[] getOESMatrix() {
+ mSurfaceTextureWrapper.getTransformMatrix(mOESMatrix);
+ return mOESMatrix;
+ }
+
+ @Override
+ public boolean isMatrixInverseWidthHeight() {
+ return true;
+ }
+
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ @Override
+ public void destroySurface() {
+
+ if (CameraInit.getConfig().isDebuggable()) {
+ Log.d(TAG, "destroySurface");
+ }
+ mReceiveFirstFrame = false;
+ mHasNewFrame = false;
+ if (mSurfaceTextureWrapper != null) {
+ mSurfaceTextureWrapper.release();
+ }
+ if (mComboCallback != null) {
+ mComboCallback.removeCallback(mCaptureCallback);
+ }
+
+ if (mCamera != null) {
+ mCamera.getCameraStateImmediatelyObservable().removeListener(this);
+ }
+
+ synchronized (mResultLock) {
+ mCurrentCaptureResult = null;
+ mCameraXCurrentCaptureResult = null;
+ }
+
+ if (mComboCallback != null) {
+ mComboCallback.removeCallback(mCaptureCallback);
+ }
+
+ mMemManager.clear();
+ mReleaseManager.clear();
+ }
+
+
+ @Override
+ public Camera2CameraImpl getCamera() {
+ return mCamera;
+ }
+
+ @Override
+ public void onCameraStateChanged(CameraState cameraState) {
+ if (cameraState == CameraState.CLOSING || cameraState == CameraState.CLOSED) {
+ if (CameraInit.getConfig().isDebuggable()) {
+ Log.d(TAG, "camera state: " + cameraState + " clear invalid capture result ");
+ }
+ synchronized (mResultLock) {
+ mCurrentCaptureResult = null;
+ }
+
+
+ mMemManager.clear();
+ }
+ }
+
+ public void cacheCameraXCaptureResult(Camera2CameraCaptureResult captureResult) {
+ mReleaseManager.cacheCaptureResult(captureResult);
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/GLConstant.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/GLConstant.java
new file mode 100644
index 000000000..0cc9b39c5
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/GLConstant.java
@@ -0,0 +1,41 @@
+package com.quark.quamera.render;
+
+
+public class GLConstant {
+ public static final String VERSION = "1.0.0";
+
+ public static final String TAG = "CameraVideoView";
+
+ public static final String SHADER_DEFAULT_VERTEX = "" +
+ "attribute vec4 position;\n" +
+ "attribute vec4 inputTextureCoordinate;\n" +
+ "\n" +
+ "uniform mat4 uPosMtx;\n" +
+ "uniform mat4 uTexMtx;\n" +
+ "varying vec2 textureCoordinate;\n" +
+ "void main() {\n" +
+ " gl_Position = uPosMtx * position;\n" +
+ " textureCoordinate = (uTexMtx * inputTextureCoordinate).xy;\n" +
+ "}";
+
+ public static final String SHADER_DEFAULT_FRAGMENT_OES = "" +
+// " #version 300 es\n" +
+
+// "#extension GL_OES_EGL_image_external_essl3 : require\n" +
+ "#extension GL_OES_EGL_image_external : require\n" +
+
+ "precision mediump float;\n" +
+ "varying vec2 textureCoordinate;\n" +
+ "uniform samplerExternalOES sTexture;\n" +
+ "void main() {\n" +
+ " gl_FragColor = texture2D(sTexture, textureCoordinate);\n" +
+ "}";
+
+ public static final String SHADER_DEFAULT_FRAGMENT_NOT_OES = "" +
+ "precision mediump float;\n" +
+ "varying vec2 textureCoordinate;\n" +
+ "uniform sampler2D sTexture;\n" +
+ "void main() {\n" +
+ " gl_FragColor = texture2D(sTexture, textureCoordinate);\n" +
+ "}";
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/GlFboFilter.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/GlFboFilter.java
new file mode 100644
index 000000000..c2650afb4
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/GlFboFilter.java
@@ -0,0 +1,432 @@
+package com.quark.quamera.render;
+
+import android.annotation.TargetApi;
+import android.graphics.Bitmap;
+import android.graphics.PointF;
+import android.opengl.GLES11Ext;
+import android.opengl.GLES20;
+import android.util.Log;
+
+
+import com.quark.quamera.util.GlCommonUtil;
+import com.quark.quamera.util.MatrixUtils;
+import com.quark.quamera.util.OpenGlUtils;
+
+import java.nio.FloatBuffer;
+import java.util.LinkedList;
+
+import static com.quark.quamera.render.CropFboFilter.doSnapshot;
+
+
+@TargetApi(18)
+//TODO 后面将filter相同内容抽象成基类
+
+public class GlFboFilter {
+
+ private final FloatBuffer mVtxBuf = OpenGlUtils.createSquareVtx();
+ protected float[] mPosMtx = OpenGlUtils.createIdentityMtx();
+ private float[] mNormalPosMtx = OpenGlUtils.createIdentityMtx();
+ private float[] mIdentityMtx = OpenGlUtils.createIdentityMtx();
+ private float[] mFlipXPosMtx = MatrixUtils.flipF(OpenGlUtils.createIdentityMtx(), true, false);
+ private final float[] mFlipYPosMtx = MatrixUtils.flipF(OpenGlUtils.createIdentityMtx(), false, true);
+
+ protected int mInputTextureId = -1;
+ private int mProgram = -1;
+ private int maPositionHandle = -1;
+ private int maTexCoordHandle = -1;
+ private int muPosMtxHandle = -1;
+ private int muTexMtxHandle = -1;
+ private int mSingleStepOffsetHandler = -1;
+
+ private final int[] mTexId = new int[]{0};
+
+ private int mFboId = -1;
+ private int mRboId = -1;
+
+ protected int mInputWidth = -1;
+ protected int mInputHeight = -1;
+
+ protected int mOutputWidth = -1;
+ protected int mOutputHeight = -1;
+
+ private boolean mIsExternalOES;//是否从外部纹理读取数据
+
+ private final LinkedList mRunOnDraw;
+ private String mVertex;
+ private String mFragment;
+
+ private int mX = 0;
+ private int mY = 0;
+ private boolean mNeedClear = true;
+
+ //TODO only for test code，always false when commit
+ boolean mDoSnapshot = false;
+
+ private boolean mPrepared = false;
+
+
+ public GlFboFilter() {
+ this(true);
+ }
+
+ public GlFboFilter(boolean isExternalOES) {
+ mIsExternalOES = isExternalOES;
+ mRunOnDraw = new LinkedList<>();
+ if (isExternalOES) {
+ mVertex = GLConstant.SHADER_DEFAULT_VERTEX;
+ mFragment = GLConstant.SHADER_DEFAULT_FRAGMENT_OES;
+ } else {
+ mVertex = GLConstant.SHADER_DEFAULT_VERTEX;
+ mFragment = GLConstant.SHADER_DEFAULT_FRAGMENT_NOT_OES;
+ }
+ }
+
+ public void normalPosMtx() {
+ mPosMtx = mNormalPosMtx;
+ }
+
+ public void flipPosMtxX() {
+ mPosMtx = mFlipXPosMtx;
+ }
+
+ public void flipPosMtxY() {
+ mPosMtx = mFlipYPosMtx;
+ }
+
+ public void setInputSize(int width, int height) {
+ mInputWidth = width;
+ mInputHeight = height;
+ mOutputWidth = mInputWidth;
+ mOutputHeight = mInputHeight;
+ }
+
+ public void setXY(int x, int y) {
+ mX = x;
+ mY = y;
+ }
+
+ public void setOutputSize(int width, int height) {
+ mOutputWidth = width;
+ mOutputHeight = height;
+ }
+
+ public int getOutputWidth() {
+ return mOutputWidth;
+ }
+
+ public int getOutputHeight() {
+ return mOutputHeight;
+ }
+
+ public void setNeedClear(boolean need) {
+ mNeedClear = need;
+ }
+
+ public void clear() {
+ GLES20.glClearColor(0f, 0f, 0f, 1f);
+ GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
+ }
+
+ public void prepare() {
+ Log.d("e", "prepare createFrameBuffer" + mPrepared + ", width " + mInputWidth + ", height" + mInputHeight);
+ if (mPrepared) {
+ return;
+ }
+
+ loadShaderAndParams(mVertex, mFragment);
+ createEffectTexture();
+ mPrepared = true;
+ }
+
+ public void setInputTextureId(int textureId) {
+ mInputTextureId = textureId;
+ }
+
+ private void loadShaderAndParams(String vertex, String fragment) {
+ GlCommonUtil.checkGlError("initSH_S");
+ mProgram = GlCommonUtil.createProgram(vertex, fragment);
+ maPositionHandle = GLES20.glGetAttribLocation(mProgram, "position");
+ maTexCoordHandle = GLES20.glGetAttribLocation(mProgram, "inputTextureCoordinate");
+ muPosMtxHandle = GLES20.glGetUniformLocation(mProgram, "uPosMtx");
+ muTexMtxHandle = GLES20.glGetUniformLocation(mProgram, "uTexMtx");
+ mSingleStepOffsetHandler = GLES20.glGetUniformLocation(mProgram, "singleStepOffset");
+
+ if (mSingleStepOffsetHandler != -1) {
+ setFloatVec2(mSingleStepOffsetHandler, new float[]{2.5f / mInputWidth, 2.5f / mInputHeight});
+ }
+ GlCommonUtil.checkGlError("initSH_E");
+ }
+
+ public int getInputWidth() {
+ return mInputWidth;
+ }
+
+ public int getInputHeight() {
+ return mInputHeight;
+ }
+
+ private void createEffectTexture() {
+ if (mInputWidth <= 0 || mInputHeight <= 0) {
+ return;
+ }
+ GlCommonUtil.checkGlError("initFBO_S");
+ createFrameBuffer();
+ GLES20.glGenTextures(1, mTexId, 0);
+
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mFboId);
+
+
+ GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTexId[0]);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
+
+ GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA,
+ mOutputWidth, mOutputHeight, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);
+
+ GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER,
+ GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, mTexId[0], 0);
+
+ if (GLES20.glCheckFramebufferStatus(GLES20.GL_FRAMEBUFFER) !=
+ GLES20.GL_FRAMEBUFFER_COMPLETE) {
+ throw new RuntimeException("glCheckFramebufferStatus()");
+ }
+ GlCommonUtil.checkGlError("initFBO_E");
+ }
+
+
+ public int getOutputTextureId() {
+ return mTexId[0];
+ }
+
+ protected void runOnDraw(final Runnable runnable) {
+ synchronized (mRunOnDraw) {
+ mRunOnDraw.addLast(runnable);
+ }
+ }
+
+ protected void runPendingOnDrawTasks() {
+ while (!mRunOnDraw.isEmpty()) {
+ mRunOnDraw.removeFirst().run();
+ }
+ }
+
+ public void draw(float[] tex_mtx) {
+ if (tex_mtx == null) {
+ tex_mtx = mIdentityMtx;
+ }
+ draw(tex_mtx, mPosMtx);
+ }
+
+ public void draw(float[] tex_mtx, final float[] posMatrix) {
+ if (-1 == mProgram || mInputTextureId == -1 || mInputWidth == -1) {
+ return;
+ }
+
+ GlCommonUtil.checkGlError("draw_S");
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mFboId);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ GLES20.glViewport(mX, mY, mOutputWidth, mOutputHeight);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ if (mNeedClear) {
+ GLES20.glClearColor(0f, 0f, 0f, 0f);
+ GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
+ }
+ GLES20.glUseProgram(mProgram);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ runPendingOnDrawTasks();
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ mVtxBuf.position(0);
+ GLES20.glVertexAttribPointer(maPositionHandle,
+ 3, GLES20.GL_FLOAT, false, 4 * (3 + 2), mVtxBuf);
+ GLES20.glEnableVertexAttribArray(maPositionHandle);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ mVtxBuf.position(3);
+ GLES20.glVertexAttribPointer(maTexCoordHandle,
+ 2, GLES20.GL_FLOAT, false, 4 * (3 + 2), mVtxBuf);
+ GLES20.glEnableVertexAttribArray(maTexCoordHandle);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ if (muPosMtxHandle >= 0) {
+ GLES20.glUniformMatrix4fv(muPosMtxHandle, 1, false, posMatrix, 0);
+ }
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ if (muTexMtxHandle >= 0) {
+ GLES20.glUniformMatrix4fv(muTexMtxHandle, 1, false, tex_mtx, 0);
+ }
+
+ GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+ if (mIsExternalOES) {
+ GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, mInputTextureId);
+ } else {
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mInputTextureId);
+ }
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
+
+ //only for test code
+ if (mDoSnapshot) {
+ Bitmap result = doSnapshot(mOutputWidth, mOutputHeight);
+ Log.e("SnapShotTest", "test " + result.getHeight());
+ }
+
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ GLES20.glDisableVertexAttribArray(maPositionHandle);
+ GLES20.glDisableVertexAttribArray(maTexCoordHandle);
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+
+ if (mIsExternalOES) {
+ GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, 0);
+ } else {
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+ }
+ GLES20.glUseProgram(0);
+
+ GlCommonUtil.checkGlError("draw_E");
+ }
+
+ protected void setInteger(final int location, final int intValue) {
+ runOnDraw(new Runnable() {
+ @Override
+ public void run() {
+ GLES20.glUniform1i(location, intValue);
+ }
+ });
+ }
+
+ protected void setFloat(final int location, final float floatValue) {
+ runOnDraw(new Runnable() {
+ @Override
+ public void run() {
+ GLES20.glUniform1f(location, floatValue);
+ }
+ });
+ }
+
+ protected void setFloatVec2(final int location, final float[] arrayValue) {
+ runOnDraw(new Runnable() {
+ @Override
+ public void run() {
+ GLES20.glUniform2fv(location, 1, FloatBuffer.wrap(arrayValue));
+ }
+ });
+ }
+
+ protected void setFloatVec3(final int location, final float[] arrayValue) {
+ runOnDraw(new Runnable() {
+ @Override
+ public void run() {
+ GLES20.glUniform3fv(location, 1, FloatBuffer.wrap(arrayValue));
+ }
+ });
+ }
+
+ protected void setFloatVec4(final int location, final float[] arrayValue) {
+ runOnDraw(new Runnable() {
+ @Override
+ public void run() {
+ GLES20.glUniform4fv(location, 1, FloatBuffer.wrap(arrayValue));
+ }
+ });
+ }
+
+ protected void setFloatArray(final int location, final float[] arrayValue) {
+ runOnDraw(new Runnable() {
+ @Override
+ public void run() {
+ GLES20.glUniform1fv(location, arrayValue.length, FloatBuffer.wrap(arrayValue));
+ }
+ });
+ }
+
+ protected void setPoint(final int location, final PointF point) {
+ runOnDraw(new Runnable() {
+
+ @Override
+ public void run() {
+ float[] vec2 = new float[2];
+ vec2[0] = point.x;
+ vec2[1] = point.y;
+ GLES20.glUniform2fv(location, 1, vec2, 0);
+ }
+ });
+ }
+
+ protected void setUniformMatrix3f(final int location, final float[] matrix) {
+ runOnDraw(new Runnable() {
+
+ @Override
+ public void run() {
+ GLES20.glUniformMatrix3fv(location, 1, false, matrix, 0);
+ }
+ });
+ }
+
+ protected void setUniformMatrix4f(final int location, final float[] matrix) {
+ runOnDraw(new Runnable() {
+
+ @Override
+ public void run() {
+ GLES20.glUniformMatrix4fv(location, 1, false, matrix, 0);
+ }
+ });
+ }
+
+ private void createFrameBuffer() {
+ int[] fboId = new int[]{0};
+// int[] rboId = new int[]{0};
+ GLES20.glGenFramebuffers(1, fboId, 0);
+// GLES20.glGenRenderbuffers(1, rboId, 0);
+ mFboId = fboId[0];
+// mRboId = rboId[0];
+ Log.d("e", "createFrameBuffer: ");
+ }
+
+ private void releaseFrameBuffer() {
+ if (mFboId != -1) {
+ int[] fboId = new int[]{mFboId};
+ GLES20.glDeleteFramebuffers(1, fboId, 0);
+ mFboId = -1;
+ }
+// if (mRboId != -1) {
+// int[] rboId = new int[]{mRboId};
+// GLES20.glDeleteRenderbuffers(1, rboId, 0);
+// mRboId = -1;
+// }
+ }
+
+ private void releaseProgram() {
+ if (mProgram == -1) {
+ return;
+ }
+ GLES20.glDeleteProgram(mProgram);
+ }
+
+ public void release() {
+ releaseFrameBuffer();
+ releaseProgram();
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/ICameraRender.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/ICameraRender.java
new file mode 100644
index 000000000..2349c825f
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/ICameraRender.java
@@ -0,0 +1,32 @@
+package com.quark.quamera.render;
+
+import android.opengl.EGLContext;
+
+import com.quark.quamera.camera.camera.Camera2CameraImpl;
+
+import java.util.Map;
+
+public interface ICameraRender {
+
+ boolean update(EGLContext context, int textureId, Map cameraInfo);
+
+ boolean needRender();
+
+ public interface ICameraFrameAvailableListener {
+ public void onCameraFrameAvailable();
+ }
+
+ public void setCameraFrameAvailableListener(ICameraFrameAvailableListener listener);
+
+
+ int[] getCameraCaptureSize();
+
+ float[] getOESMatrix();
+
+ boolean isMatrixInverseWidthHeight();
+
+
+ void destroySurface();
+
+ Camera2CameraImpl getCamera();
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/ICameraShowViewChangeListener.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/ICameraShowViewChangeListener.java
new file mode 100644
index 000000000..164a2164e
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/ICameraShowViewChangeListener.java
@@ -0,0 +1,12 @@
+package com.quark.quamera.render;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/7/27
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+public interface ICameraShowViewChangeListener {
+ void onCameraShowLayoutChanged(float x, float y, float with, float height);
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/IGLFilter.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/IGLFilter.java
new file mode 100644
index 000000000..32fb4a997
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/IGLFilter.java
@@ -0,0 +1,17 @@
+package com.quark.quamera.render;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/1/28
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+public interface IGLFilter {
+
+ public int getOutputWidth();
+
+ public int getOutputHeight();
+
+ public int getOutputTextureId();
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/ScreenRenderFilter.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/ScreenRenderFilter.java
new file mode 100644
index 000000000..0bb1a55fc
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/ScreenRenderFilter.java
@@ -0,0 +1,245 @@
+package com.quark.quamera.render;
+
+import android.annotation.TargetApi;
+import android.opengl.GLES11Ext;
+import android.opengl.GLES20;
+import android.opengl.Matrix;
+
+import com.quark.quamera.util.GlCommonUtil;
+import com.quark.quamera.util.MatrixUtils;
+import com.quark.quamera.util.OpenGlUtils;
+
+import java.nio.FloatBuffer;
+
+
+@TargetApi(18)
+//TODO 后面将filter相同内容抽象成基类
+public class ScreenRenderFilter {
+
+ private final FloatBuffer mVtxBuf = OpenGlUtils.createSquareVtx();
+ private float[] mPosMtx = OpenGlUtils.createIdentityMtx();
+ private final float[] mNormalPosMtx = OpenGlUtils.createIdentityMtx();
+
+ private final float[] mFlipXPosMtx = MatrixUtils.flipF(OpenGlUtils.createIdentityMtx(), true, false);
+ private final float[] mFlipYPosMtx = MatrixUtils.flipF(OpenGlUtils.createIdentityMtx(), false, true);
+
+ protected int mInputTextureId = -1;
+ private int mProgram = -1;
+ private int maPositionHandle = -1;
+ private int maTexCoordHandle = -1;
+ private int muPosMtxHandle = -1;
+ private int muTexMtxHandle = -1;
+
+ private int mInputWidth = -1;
+ private int mInputHeight = -1;
+
+ private int mViewPortWidth = -1;
+ private int mViewPortHeight = -1;
+
+ private final String mVertex;
+ private final String mFragment;
+ private final boolean mIsExternalOES = false;
+
+ private int mX = 0;
+ private int mY = 0;
+
+ private boolean mNeedClear = true;
+
+ private boolean mPrepared = false;
+
+ public ScreenRenderFilter() {
+ mVertex = GLConstant.SHADER_DEFAULT_VERTEX;
+ mFragment = GLConstant.SHADER_DEFAULT_FRAGMENT_NOT_OES;
+ }
+
+
+ public void normalPosMtx() {
+ mPosMtx = mNormalPosMtx;
+ }
+
+ public void flipPosMtxX() {
+ mPosMtx = mFlipXPosMtx;
+ }
+
+ public void flipPosMtxY() {
+ mPosMtx = mFlipYPosMtx;
+ }
+
+ public void setInputSize(int width, int height) {
+ boolean isChange = mInputWidth != width || mInputWidth != height;
+ mInputWidth = width;
+ mInputHeight = height;
+ if (isChange) {
+ setScaleType();
+ }
+ }
+
+
+ public void setViewPort(int width, int height) {
+ boolean isChange = mViewPortWidth != width || mViewPortHeight != height;
+ mViewPortWidth = width;
+ mViewPortHeight = height;
+ if (isChange) {
+ setScaleType();
+ }
+ }
+
+ public int getViewPortWidth() {
+ return mViewPortWidth;
+ }
+
+ public int getViewPortHeight() {
+ return mViewPortHeight;
+ }
+
+ public void setNeedClear(boolean need) {
+ mNeedClear = need;
+ }
+
+ public void clear() {
+ GLES20.glClearColor(0f, 0f, 0f, 1f);
+ GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
+ }
+
+ public void prepare() {
+ if (mPrepared) {
+ return;
+ }
+
+ loadShaderAndParams(mVertex, mFragment);
+
+ mPrepared = true;
+ }
+
+ public void setInputTextureId(int textureId) {
+ mInputTextureId = textureId;
+ }
+
+ private void loadShaderAndParams(String vertex, String fragment) {
+ GlCommonUtil.checkGlError("initSH_S");
+ mProgram = GlCommonUtil.createProgram(vertex, fragment);
+ maPositionHandle = GLES20.glGetAttribLocation(mProgram, "position");
+ maTexCoordHandle = GLES20.glGetAttribLocation(mProgram, "inputTextureCoordinate");
+ muPosMtxHandle = GLES20.glGetUniformLocation(mProgram, "uPosMtx");
+ muTexMtxHandle = GLES20.glGetUniformLocation(mProgram, "uTexMtx");
+ GlCommonUtil.checkGlError("initSH_E");
+ }
+
+ public int getInputWidth() {
+ return mInputWidth;
+ }
+
+ public int getInputHeight() {
+ return mInputHeight;
+ }
+
+
+ public void setScaleType() {
+
+ if (mInputWidth <= 0
+ || mInputHeight <= 0
+ || mViewPortHeight <= 0
+ || mViewPortWidth <= 0) {
+ return;
+ }
+ mPosMtx = OpenGlUtils.createIdentityMtx();
+
+ getVexPositionMatrix(mInputWidth, mInputHeight, mViewPortWidth, mViewPortHeight, mPosMtx);
+
+ }
+
+ public static void getVexPositionMatrix(int iWidth, int iHeight, int oWidth, int oHeight, float[] posMatrix) {
+ float input_radio = (float) iHeight / (float) iWidth;
+ float out_radio = (float) oHeight / (float) oWidth;
+ if (input_radio > out_radio) {
+ Matrix.scaleM(posMatrix, 0, 1f, (float) input_radio / (float) out_radio, 1.0F);
+ } else {
+ Matrix.scaleM(posMatrix, 0, (float) out_radio / (float) input_radio, 1f, 1.0F);
+ }
+ }
+
+
+ private float[] mTexMtx = OpenGlUtils.createIdentityMtx();
+
+ public float[] getPosMtx() {
+ return mPosMtx;
+ }
+
+
+ public void draw() {
+ if (-1 == mProgram || mInputTextureId == -1 || mInputWidth == -1) {
+ return;
+ }
+
+ GlCommonUtil.checkGlError("draw_S");
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+
+
+ GLES20.glViewport(mX, mY, mViewPortWidth, mViewPortHeight);
+
+
+ if (mNeedClear) {
+ GLES20.glClearColor(0f, 0f, 0f, 1f);
+ GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
+ }
+
+ GLES20.glUseProgram(mProgram);
+
+
+ mVtxBuf.position(0);
+ GLES20.glVertexAttribPointer(maPositionHandle,
+ 3, GLES20.GL_FLOAT, false, 4 * (3 + 2), mVtxBuf);
+ GLES20.glEnableVertexAttribArray(maPositionHandle);
+
+
+ mVtxBuf.position(3);
+ GLES20.glVertexAttribPointer(maTexCoordHandle,
+ 2, GLES20.GL_FLOAT, false, 4 * (3 + 2), mVtxBuf);
+ GLES20.glEnableVertexAttribArray(maTexCoordHandle);
+
+
+ if (muPosMtxHandle >= 0) {
+ GLES20.glUniformMatrix4fv(muPosMtxHandle, 1, false, mPosMtx, 0);
+ }
+
+ if (muTexMtxHandle >= 0) {
+ GLES20.glUniformMatrix4fv(muTexMtxHandle, 1, false, mTexMtx, 0);
+ }
+
+ GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+ if (mIsExternalOES) {
+ GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, mInputTextureId);
+ } else {
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mInputTextureId);
+ }
+
+
+ GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
+
+
+ GLES20.glDisableVertexAttribArray(maPositionHandle);
+ GLES20.glDisableVertexAttribArray(maTexCoordHandle);
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+
+ if (mIsExternalOES) {
+ GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, 0);
+ } else {
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+ }
+ GLES20.glUseProgram(0);
+
+ GlCommonUtil.checkGlError("draw_E");
+ }
+
+
+ private void releaseProgram() {
+ if (mProgram == -1) {
+ return;
+ }
+ GLES20.glDeleteProgram(mProgram);
+ }
+
+ public void release() {
+ releaseProgram();
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/SnapshotFilter.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/SnapshotFilter.java
new file mode 100644
index 000000000..38e1f0438
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/SnapshotFilter.java
@@ -0,0 +1,306 @@
+package com.quark.quamera.render;
+
+import android.annotation.TargetApi;
+import android.graphics.Bitmap;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.opengl.GLES11Ext;
+import android.opengl.GLES20;
+import android.util.Log;
+
+import com.quark.quamera.render.photo.ExportPhoto;
+import com.quark.quamera.render.photo.SnapShotCommand;
+import com.quark.quamera.util.CameraLogger;
+import com.quark.quamera.util.GlCommonUtil;
+import com.quark.quamera.util.MatrixUtils;
+import com.quark.quamera.util.OpenGlUtils;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+import java.util.LinkedList;
+
+import static com.quark.quamera.render.ScreenRenderFilter.getVexPositionMatrix;
+
+
+@TargetApi(18)
+//TODO 后面将filter相同内容抽象成基类
+public class SnapshotFilter {
+
+ private final FloatBuffer mVtxBuf = OpenGlUtils.createSquareVtx();
+ private final float[] mPosMtx = MatrixUtils.flipF(OpenGlUtils.createIdentityMtx(), false, true);
+ private final float[] mTexMtx = OpenGlUtils.createIdentityMtx();
+
+ protected int mInputTextureId = -1;
+ private int mProgram = -1;
+ private int maPositionHandle = -1;
+ private int maTexCoordHandle = -1;
+ private int muPosMtxHandle = -1;
+ private int muTexMtxHandle = -1;
+
+ private final int[] mTexId = new int[]{0};
+
+ private int mFboId = -1;
+
+ protected int mInputWidth = -1;
+ protected int mInputHeight = -1;
+
+ protected int mOutputWidth = -1;
+ protected int mOutputHeight = -1;
+
+ private boolean mIsExternalOES;//是否从外部纹理读取数据
+
+ private final LinkedList mRunOnDraw;
+ private final String mVertex;
+ private final String mFragment;
+
+ private boolean mNeedClear = true;
+
+ private boolean mPrepared = false;
+
+
+ public SnapshotFilter() {
+ mRunOnDraw = new LinkedList<>();
+ mVertex = GLConstant.SHADER_DEFAULT_VERTEX;
+ mFragment = GLConstant.SHADER_DEFAULT_FRAGMENT_NOT_OES;
+ }
+
+
+ public void setInputSize(int width, int height) {
+ mInputWidth = width;
+ mInputHeight = height;
+ mOutputWidth = mInputWidth;
+ mOutputHeight = mInputHeight;
+ }
+
+
+ public void setOutputSize(int width, int height) {
+ mOutputWidth = width;
+ mOutputHeight = height;
+ }
+
+ public int getOutputWidth() {
+ return mOutputWidth;
+ }
+
+ public int getOutputHeight() {
+ return mOutputHeight;
+ }
+
+ public void setNeedClear(boolean need) {
+ mNeedClear = need;
+ }
+
+
+ public void prepare() {
+ if (mPrepared) {
+ return;
+ }
+ loadShaderAndParams(mVertex, mFragment);
+ createEffectTexture();
+ mPrepared = true;
+ }
+
+ public void setInputTextureId(int textureId) {
+ mInputTextureId = textureId;
+ }
+
+ private void loadShaderAndParams(String vertex, String fragment) {
+ GlCommonUtil.checkGlError("initSH_S");
+ mProgram = GlCommonUtil.createProgram(vertex, fragment);
+ maPositionHandle = GLES20.glGetAttribLocation(mProgram, "position");
+ maTexCoordHandle = GLES20.glGetAttribLocation(mProgram, "inputTextureCoordinate");
+ muPosMtxHandle = GLES20.glGetUniformLocation(mProgram, "uPosMtx");
+ muTexMtxHandle = GLES20.glGetUniformLocation(mProgram, "uTexMtx");
+ GlCommonUtil.checkGlError("initSH_E");
+ }
+
+ public int getInputWidth() {
+ return mInputWidth;
+ }
+
+ public int getInputHeight() {
+ return mInputHeight;
+ }
+
+ private void createEffectTexture() {
+ if (mInputWidth <= 0 || mInputHeight <= 0) {
+ return;
+ }
+ GlCommonUtil.checkGlError("initFBO_S");
+ createFrameBuffer();
+ GLES20.glGenTextures(1, mTexId, 0);
+
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mFboId);
+
+ GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTexId[0]);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
+
+ GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA,
+ mOutputWidth, mOutputHeight, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);
+
+ GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER,
+ GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, mTexId[0], 0);
+
+ if (GLES20.glCheckFramebufferStatus(GLES20.GL_FRAMEBUFFER) !=
+ GLES20.GL_FRAMEBUFFER_COMPLETE) {
+ throw new RuntimeException("glCheckFramebufferStatus()");
+ }
+ GlCommonUtil.checkGlError("initFBO_E");
+ }
+
+
+ public int getOutputTextureId() {
+ return mTexId[0];
+ }
+
+ protected void runOnDraw(final Runnable runnable) {
+ synchronized (mRunOnDraw) {
+ mRunOnDraw.addLast(runnable);
+ }
+ }
+
+ protected void runPendingOnDrawTasks() {
+ while (!mRunOnDraw.isEmpty()) {
+ mRunOnDraw.removeFirst().run();
+ }
+ }
+
+
+ public Bitmap snapshot(SnapShotCommand snapShotCommand) {
+ if (-1 == mProgram || mInputTextureId == -1 || mInputWidth == -1) {
+ return null;
+ }
+
+ GlCommonUtil.checkGlError("draw_S");
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mFboId);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ GLES20.glViewport(0, 0, mOutputWidth, mOutputHeight);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ if (mNeedClear) {
+ GLES20.glClearColor(0f, 1f, 0f, 1f);
+ GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
+ }
+
+ GLES20.glUseProgram(mProgram);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ runPendingOnDrawTasks();
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ mVtxBuf.position(0);
+ GLES20.glVertexAttribPointer(maPositionHandle,
+ 3, GLES20.GL_FLOAT, false, 4 * (3 + 2), mVtxBuf);
+ GLES20.glEnableVertexAttribArray(maPositionHandle);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ mVtxBuf.position(3);
+ GLES20.glVertexAttribPointer(maTexCoordHandle,
+ 2, GLES20.GL_FLOAT, false, 4 * (3 + 2), mVtxBuf);
+ GLES20.glEnableVertexAttribArray(maTexCoordHandle);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ if (muPosMtxHandle >= 0) {
+ GLES20.glUniformMatrix4fv(muPosMtxHandle, 1, false, mPosMtx, 0);
+ }
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ if (muTexMtxHandle >= 0) {
+ GLES20.glUniformMatrix4fv(muTexMtxHandle, 1, false, mTexMtx, 0);
+ }
+
+ GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mInputTextureId);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
+
+ Bitmap result = snapshotInner(snapShotCommand);
+
+ GlCommonUtil.checkGlError("draw_S");
+
+ GLES20.glDisableVertexAttribArray(maPositionHandle);
+ GLES20.glDisableVertexAttribArray(maTexCoordHandle);
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+ GLES20.glUseProgram(0);
+
+ GlCommonUtil.checkGlError("draw_E");
+
+ return result;
+ }
+
+
+ private void createFrameBuffer() {
+ int[] fboId = new int[]{0};
+ GLES20.glGenFramebuffers(1, fboId, 0);
+ mFboId = fboId[0];
+ Log.d("e", "createFrameBuffer: ");
+ }
+
+ private void releaseFrameBuffer() {
+ if (mFboId != -1) {
+ int[] fboId = new int[]{mFboId};
+ GLES20.glDeleteFramebuffers(1, fboId, 0);
+ mFboId = -1;
+ }
+ }
+
+ private void releaseProgram() {
+ if (mProgram == -1) {
+ return;
+ }
+ GLES20.glDeleteProgram(mProgram);
+ }
+
+ public void release() {
+ if (mTexId[0] > 0) {
+ GlCommonUtil.deleteGLTexture(mTexId);
+ }
+ releaseFrameBuffer();
+ releaseProgram();
+ }
+
+ private Bitmap snapshotInner(SnapShotCommand snapShotCommand) {
+ int[] viewport = new int[4];
+ GLES20.glGetIntegerv(GLES20.GL_VIEWPORT, viewport, 0);
+ int x = viewport[0];
+ int y = viewport[1];
+ int width = viewport[2];
+ int height = viewport[3];
+
+ Rect rect = snapShotCommand.getGLSnapshotRect(width, height, false);
+
+ final ByteBuffer rgbaData = ByteBuffer.allocateDirect(rect.width() * rect.height() * 4);
+ rgbaData.order(ByteOrder.nativeOrder());
+
+ GLES20.glReadPixels(rect.left, rect.top, rect.width(), rect.height(), GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, rgbaData);
+
+ Bitmap bitmap = Bitmap.createBitmap(rect.width(), rect.height(), Bitmap.Config.ARGB_8888);
+ bitmap.copyPixelsFromBuffer(rgbaData);
+
+ CameraLogger.i("CameraVideoView", "take snapshot " + GLES20.glGetError());
+
+ return bitmap;
+ }
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/AlgTextureConsumer.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/AlgTextureConsumer.java
new file mode 100644
index 000000000..10e503098
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/AlgTextureConsumer.java
@@ -0,0 +1,369 @@
+package com.quark.quamera.render.detector;
+
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/1/25
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.graphics.PixelFormat;
+import android.media.Image;
+import android.media.ImageReader;
+import android.opengl.EGLContext;
+import android.os.Build;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.util.Log;
+import android.view.Surface;
+
+import androidx.annotation.RequiresApi;
+
+import com.quark.quamera.camera.anotaion.ExecutedBy;
+import com.quark.quamera.util.CameraLogger;
+import com.quark.quamera.util.CameraShould;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+
+import static com.quark.quamera.render.detector.AlgTextureConsumer.OutputType.NV21;
+
+
+@RequiresApi(api = Build.VERSION_CODES.KITKAT)
+public class AlgTextureConsumer implements ImageReader.OnImageAvailableListener, IAlgTextureConsumer {
+
+
+ private NV21Buffer mNV21Buffer;
+ private Handler mHandler;
+ private ImageReader mImageReader;
+
+ private GLAlgSurfaceProcessPipe mGLAlgSurfaceProcessPipe;
+
+ private OnAlgCpuDataReceiver mOnAlgCpuDataReceiver;
+
+ private Surface mSurface;
+
+ private final Context mContext;
+
+ public enum OutputType {
+ RGBA_8888,
+ NV21
+ }
+
+ private OutputType mOutputType = NV21;
+
+
+ public AlgTextureConsumer(Context context) {
+ mContext = context;
+ }
+
+
+ private void startThread() {
+ if (mHandler == null) {
+ HandlerThread handlerThread = new HandlerThread("elgCodec");
+ handlerThread.start();
+ mHandler = new Handler(handlerThread.getLooper());
+ }
+ }
+
+ private int mInWidth;
+ private int mInHeight;
+
+
+ public void updateInputTexture(EGLContext eglContext, int textureId, int width, int height, long timeStamp) {
+ if (isReleased()) {
+ return;
+ }
+ startThread();
+
+ synchronized (AlgTextureConsumer.this) {
+ if (mGLDrawCommandList.size() > 2) {
+ mGLDrawCommandList.remove(0);
+ }
+ mGLDrawCommandList.add(new GLDrawCommand(eglContext, textureId, width, height, timeStamp));
+ }
+
+ doLatestCommand();
+ }
+
+ private synchronized void doLatestCommand() {
+ if (isReleased()) {
+ return;
+ }
+ if (mProcessingCommand == null) {
+
+ //获取最新帧
+ int nextIndex = mGLDrawCommandList.size() - 1;
+ if (nextIndex >= 0) {
+ mProcessingCommand = mGLDrawCommandList.remove(nextIndex);
+ mGLDrawCommandList.clear();
+ }
+
+ if (mProcessingCommand != null) {
+ mHandler.post(mProcessingCommand);
+ }
+ }
+ }
+
+
+ /**
+ * 当前只缓存最后的那一帧
+ */
+ private final List mGLDrawCommandList = new ArrayList<>(1);
+
+ private GLDrawCommand mProcessingCommand;
+
+ private class GLDrawCommand implements Runnable {
+ EGLContext eglContext;
+ int textureId;
+ int width;
+ int height;
+ long timeStamp;
+
+ public GLDrawCommand(EGLContext eglContext, int textureId, int width, int height, long timeStamp) {
+ this.eglContext = eglContext;
+ this.textureId = textureId;
+ this.width = width;
+ this.height = height;
+ this.timeStamp = timeStamp;
+ }
+
+ @Override
+ public void run() {
+ if (isReleased()) {
+ return;
+ }
+ try {
+ onInputTextureSizeChange(eglContext, width, height);
+ mGLAlgSurfaceProcessPipe.draw(textureId, timeStamp);
+ } catch (Exception e) {
+ mProcessingCommand = null;
+ doLatestCommand();
+ }
+ }
+ }
+
+ private boolean isReleased() {
+ return mState == STATE.RELEASED;
+ }
+
+ @ExecutedBy("GL Thread")
+ private void onInputTextureSizeChange(EGLContext eglContext, int inWidth, int inHeight) {
+ if (mInWidth == inWidth && mInHeight == inHeight) {
+ return;
+ }
+ if (inWidth == 0 || inHeight == 0) {
+ return;
+ }
+ initGLContext(eglContext, inWidth, inHeight);
+ mInWidth = inWidth;
+ mInHeight = inHeight;
+ }
+
+ @SuppressLint("WrongConstant")
+ @ExecutedBy("GL Thread")
+ private void initGLContext(EGLContext eglContext, int inWidth, int inHeight) {
+ int surfaceWidth;
+ int surfaceHeight;
+ if (inWidth > 720) {
+ surfaceWidth = 720;
+ surfaceHeight = (int) (((float) inHeight) * 720 / inWidth);
+ } else {
+ surfaceWidth = inWidth;
+ surfaceHeight = inHeight;
+ }
+
+ //因为要转化成nv21数据格式，所以要求宽高是2的倍数，这里用4的倍数，是因为二维码库需要，差几个相素影响并不大，所以还是用4的倍数
+ surfaceWidth = surfaceWidth - surfaceWidth % 4;
+ surfaceHeight = surfaceHeight - surfaceHeight % 4;
+
+ releaseSurface();
+
+ mImageReader = ImageReader.newInstance(surfaceWidth, surfaceHeight, PixelFormat.RGBA_8888, 1
+ /**
+ * maxImages = 1 , use {@link ImageReader#acquireNextImage()} to obtain latest image
+ *
+ * @see ImageReader#acquireNextImage()
+ * @see ImageReader#acquireLatestImage()
+ */
+ );
+ mImageReader.setOnImageAvailableListener(this, mHandler);
+
+ mSurface = mImageReader.getSurface();
+
+ mGLAlgSurfaceProcessPipe = new GLAlgSurfaceProcessPipe(mContext, surfaceWidth, surfaceHeight, mSurface, eglContext);
+
+ mGLAlgSurfaceProcessPipe.prepareFilter(inWidth, inHeight);
+ }
+
+ @ExecutedBy("GL Thread")
+ private void releaseSurface() {
+ if (mGLAlgSurfaceProcessPipe != null) {
+ mGLAlgSurfaceProcessPipe.release();
+ mGLAlgSurfaceProcessPipe = null;
+ }
+
+ /**
+ * 因为ImageReader的{@link android.media.ImageReader.OnImageAvailableListener}和 close在相同的线程。所以不会存在
+ * 关闭后还尝试获取{@link ImageReader#acquireLatestImage()} }的行为风险
+ */
+ if (mImageReader != null) {
+ mImageReader.close();
+ mImageReader = null;
+ }
+
+ if (mSurface != null) {
+ mSurface.release();
+ mSurface = null;
+ }
+ }
+
+ public static long lastTimeStamp = Long.MIN_VALUE;
+
+ @Override
+ @ExecutedBy("GL Thread")
+ public void onImageAvailable(ImageReader reader) {
+ Image image = null;
+ try {
+ if (isReleased()) {
+ return;
+ }
+
+ /**
+ *
+ * {@link ImageReader#acquireLatestImage()} will case Warning (not fatal error）
+ * Unable to acquire a lockedBuffer, very likely client tries to lock more than maxImages buffers
+ *
+ * https://stackoverflow.com/questions/36419722/error-unable-to-acquire-a-lockedbuffer-very-likely-client-tries-to-lock-more-t/46910375
+ *
+ * You may provide parameter maxImages as 1 for method ImageReader.newInstance. acquireLatestImage calls acquireNextSurfaceImage before close the only one image buffer, which lead to this warning.
+ *
+ * Use acquireNextImage in this case. If maxImages is bigger than 1, acquireLatestImage don't have this problem.
+ */
+ image = reader.acquireLatestImage();
+
+ final int imageWidth = image.getWidth();
+ final int imageHeight = image.getHeight();
+ final Image.Plane[] planes = image.getPlanes();
+ if (planes == null || planes.length == 0) {
+ return;
+ }
+ Image.Plane plane = planes[0];
+
+ if (plane == null) {
+ return;
+ }
+
+ final ByteBuffer buffer = plane.getBuffer();
+ int rowStride = plane.getRowStride();
+
+ if (mOutputType == NV21) {
+ int yuv_row = (int) (((float) imageHeight) * (1f / 4/*y height*/ + 1f / 8/*uv height*/));
+ int yuv_row_stride = imageWidth * 4;
+
+ if (mNV21Buffer == null) {
+ mNV21Buffer = new NV21Buffer(imageWidth, imageHeight);
+ } else {
+ //size change
+ NV21Buffer temp = mNV21Buffer;
+ temp.readLock();
+ if (temp.getWidth() != imageWidth || temp.getHeight() != imageHeight) {
+ mNV21Buffer = new NV21Buffer(imageWidth, imageHeight);
+ }
+ temp.readUnlock();
+ }
+
+ //java层如果频繁创建byte会导致GC繁忙，这里通过读写锁的方式保证数据一致性
+ byte[] yuvData = mNV21Buffer.writeLock();
+ try {
+ for (int i = 0; i < yuv_row; i++) {
+ buffer.position(i * rowStride);
+ buffer.get(yuvData, i * yuv_row_stride, yuv_row_stride);
+ }
+ } finally {
+ mNV21Buffer.writeUnlock();
+ }
+
+
+ if (mOnAlgCpuDataReceiver != null) {
+ if (lastTimeStamp >= image.getTimestamp()) {
+ CameraShould.fail("wujm ----- fail " + lastTimeStamp + " > " + image.getTimestamp());
+ }
+ lastTimeStamp = image.getTimestamp();
+ mOnAlgCpuDataReceiver.onReceiveCpuData(mNV21Buffer, image.getTimestamp());
+ }
+ }
+ } catch (Exception e) {
+ CameraShould.fail("", e);
+ } finally {
+ if (image != null) {
+ image.close();
+ }
+
+ synchronized (AlgTextureConsumer.this) {
+ mProcessingCommand = null;
+ }
+ doLatestCommand();
+ }
+ }
+
+
+ private enum STATE {
+ RELEASED,
+ INIT
+ }
+
+ private STATE mState = STATE.INIT;
+
+
+ public void release() {
+ if (isReleased()) {
+ return;
+ }
+ synchronized (this) {
+ mState = STATE.RELEASED;
+ mProcessingCommand = null;
+ mGLDrawCommandList.clear();
+ }
+
+ if (mHandler == null) {
+ return;
+ }
+
+ final Handler handler = mHandler;
+ mHandler = null;
+
+ handler.post(() -> releaseInner(handler));
+
+ }
+
+ @Override
+ public void resume() {
+ //TODO
+ }
+
+ @Override
+ public void pause() {
+ //TODO
+ }
+
+ @Override
+ public void setOnAlgCpuDataReceiver(OnAlgCpuDataReceiver receiver) {
+ mOnAlgCpuDataReceiver = receiver;
+ }
+
+ @ExecutedBy("GL Thread")
+ private void releaseInner(Handler handler) {
+
+ releaseSurface();
+
+ if (handler != null) {
+ handler.getLooper().quitSafely();
+ }
+ }
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/AlgTextureConsumerCompat.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/AlgTextureConsumerCompat.java
new file mode 100644
index 000000000..97a0fffe1
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/AlgTextureConsumerCompat.java
@@ -0,0 +1,76 @@
+package com.quark.quamera.render.detector;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/1/29
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.content.Context;
+import android.opengl.EGLContext;
+import android.os.Build;
+
+import androidx.annotation.NonNull;
+
+import com.quark.quamera.render.entry.RenderFlowData;
+import com.quark.quamera.render.expansion.IRenderExpansion;
+
+public class AlgTextureConsumerCompat implements IAlgTextureConsumer, IRenderExpansion {
+
+ private final IAlgTextureConsumer mConsumer;
+
+ public AlgTextureConsumerCompat(Context context) {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+ mConsumer = new AlgTextureConsumer(context);
+ } else {
+ mConsumer = null;
+ }
+ }
+
+ @Override
+ public void updateInputTexture(EGLContext eglContext, int textureId, int width, int height, long timeStamp) {
+ if (mConsumer != null) {
+ mConsumer.updateInputTexture(eglContext, textureId, width, height, timeStamp);
+ }
+ }
+
+ public void release() {
+ if (mConsumer != null) {
+ mConsumer.release();
+ }
+ }
+
+ @Override
+ public void resume() {
+ if (mConsumer != null) {
+ mConsumer.resume();
+ }
+ }
+
+ @Override
+ public void pause() {
+ if (mConsumer != null) {
+ mConsumer.pause();
+ }
+ }
+
+ @Override
+ public void setOnAlgCpuDataReceiver(OnAlgCpuDataReceiver receiver) {
+ if (mConsumer != null) {
+ mConsumer.setOnAlgCpuDataReceiver(receiver);
+ }
+ }
+
+
+ @NonNull
+ @Override
+ public RenderFlowData render(@NonNull RenderFlowData input, long timestamp) {
+ return input;
+ }
+
+ @Override
+ public void onSurfaceDestroy() {
+ release();
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/BaseAlgDetector.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/BaseAlgDetector.java
new file mode 100644
index 000000000..7a8a1d4f4
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/BaseAlgDetector.java
@@ -0,0 +1,72 @@
+package com.quark.quamera.render.detector;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/1/29
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import androidx.annotation.GuardedBy;
+
+public abstract class BaseAlgDetector implements IAlgDetector {
+
+
+ @GuardedBy("mStateLock")
+ protected volatile State mState = State.UNINITIALIZED;
+
+ @Override
+ public void init() {
+ if (onInit()) {
+ mState = State.INITIALIZED;
+ } else {
+ mState = State.UNINITIALIZED;
+ }
+ }
+
+ public abstract boolean onInit();
+
+ public abstract void onRelease();
+
+ public abstract boolean onStart();
+
+ public abstract void onStop();
+
+ public abstract T detectInner(IAlgTextureConsumer.NV21Buffer buffer, long timestamp);
+
+
+ @Override
+ public T detect(IAlgTextureConsumer.NV21Buffer buffer, long timestamp) {
+ if (mState == State.RUNNING) {
+ return detectInner(buffer, timestamp);
+ }
+ return null;
+ }
+
+ @Override
+ public void release() {
+ onRelease();
+ }
+
+ @Override
+ public void start() {
+ if (mState == State.INITIALIZED) {
+ if (onStart()) {
+ mState = State.RUNNING;
+ }
+ }
+ }
+
+ @Override
+ public void stop() {
+ if (mState == State.RUNNING) {
+ mState = State.INITIALIZED;
+ onStop();
+ }
+ }
+
+ @Override
+ public State getState() {
+ return mState;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/GLAlgSurfaceProcessPipe.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/GLAlgSurfaceProcessPipe.java
new file mode 100644
index 000000000..f11fa74fb
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/GLAlgSurfaceProcessPipe.java
@@ -0,0 +1,175 @@
+package com.quark.quamera.render.detector;
+
+import android.content.Context;
+import android.opengl.EGL14;
+import android.opengl.EGLConfig;
+import android.opengl.EGLContext;
+import android.opengl.EGLDisplay;
+import android.opengl.EGLExt;
+import android.opengl.EGLSurface;
+import android.view.Surface;
+
+import com.quark.quamera.render.GlFboFilter;
+import com.quark.quamera.render.ScreenRenderFilter;
+import com.quark.quamera.render.view.BasePreviewView;
+
+
+public class GLAlgSurfaceProcessPipe {
+
+ protected EGLDisplay eglDisplay;
+ protected EGLConfig mEglConfig;
+ protected EGLContext mCurrentEglContext;
+ protected final EGLSurface eglSurface;
+
+ protected ScreenRenderFilter mScreenRenderFilter;
+ protected Rgba2YuvFilter mRgba2YuvFilter;
+
+ protected GlFboFilter mYFlipFilter;
+
+ protected final Context mContext;
+
+ protected final int mOutputSurfaceWidth;
+ protected final int mOutputSurfaceHeight;
+
+
+ public GLAlgSurfaceProcessPipe(Context context, int surfaceWidth, int surfaceHeight, Surface surface, EGLContext eglContext) {
+
+ if (surfaceWidth % 4 != 0 || surfaceHeight % 4 != 0) {
+ throw new RuntimeException("eglCreateWindowSurface 失败！");
+ }
+
+ mOutputSurfaceWidth = surfaceWidth;
+ mOutputSurfaceHeight = surfaceHeight;
+
+ mContext = context;
+ createEGLContext(eglContext);
+
+ int[] attrib_list = {
+ EGL14.EGL_NONE
+ };
+
+ //创建EGLSurface
+ eglSurface = EGL14.eglCreateWindowSurface(eglDisplay, mEglConfig, surface, attrib_list, 0);
+
+ if (eglSurface == EGL14.EGL_NO_SURFACE) {
+ throw new RuntimeException("eglCreateWindowSurface 失败！");
+ }
+
+ if (!EGL14.eglMakeCurrent(eglDisplay, eglSurface, eglSurface, mCurrentEglContext)) {
+ throw new RuntimeException("eglMakeCurrent 失败！");
+ }
+ }
+
+ public void prepareFilter(int inputWidth, int inputHeight) {
+ mYFlipFilter = new GlFboFilter(false);
+ mYFlipFilter.setInputSize(inputWidth, inputHeight);
+ mYFlipFilter.setOutputSize(mOutputSurfaceWidth, mOutputSurfaceHeight);
+ mYFlipFilter.prepare();
+
+ mRgba2YuvFilter = new Rgba2YuvFilter(mContext);
+ mRgba2YuvFilter.setInputSize(mYFlipFilter.getOutputWidth(), mYFlipFilter.getOutputHeight());
+ mRgba2YuvFilter.prepare();
+
+ mScreenRenderFilter = new ScreenRenderFilter();
+ mScreenRenderFilter.setViewPort(mRgba2YuvFilter.getOutputWidth(), mRgba2YuvFilter.getInputHeight());
+ mScreenRenderFilter.setInputSize(mRgba2YuvFilter.getOutputWidth(), mRgba2YuvFilter.getOutputHeight());
+ mScreenRenderFilter.prepare();
+ }
+
+
+ private void createEGLContext(EGLContext eglContext) {
+ //创建虚拟屏幕
+ eglDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
+
+ if (eglDisplay == EGL14.EGL_NO_DISPLAY) {
+ throw new RuntimeException("eglGetDisplay failed");
+ }
+
+ int[] versions = new int[2];
+ //初始化elgdisplay
+ if (!EGL14.eglInitialize(eglDisplay, versions, 0, versions, 1)) {
+ throw new RuntimeException("eglInitialize failed");
+ }
+
+ int glVersion = BasePreviewView.getGLVersion(mContext);
+
+ int[] attr_list = {
+ EGL14.EGL_RED_SIZE, 8,
+ EGL14.EGL_GREEN_SIZE, 8,
+ EGL14.EGL_BLUE_SIZE, 8,
+ EGL14.EGL_ALPHA_SIZE, 8,
+ EGL14.EGL_RENDERABLE_TYPE, glVersion == 2 ? EGL14.EGL_OPENGL_ES2_BIT : EGLExt.EGL_OPENGL_ES3_BIT_KHR,
+ EGL14.EGL_NONE
+ };
+
+ EGLConfig[] configs = new EGLConfig[1];
+
+ int[] num_configs = new int[1];
+
+ //配置eglDisplay 属性
+ if (!EGL14.eglChooseConfig(eglDisplay, attr_list, 0,
+ configs, 0, configs.length,
+ num_configs, 0)) {
+ throw new IllegalArgumentException("eglChooseConfig#2 failed");
+ }
+
+ mEglConfig = configs[0];
+
+ int[] ctx_attrib_list = {
+ EGL14.EGL_CONTEXT_CLIENT_VERSION, glVersion,
+ EGL14.EGL_NONE
+ };
+
+ //创建EGL 上下文
+ if (eglContext == null) {
+ mCurrentEglContext = EGL14.eglCreateContext(eglDisplay, mEglConfig, EGL14.EGL_NO_CONTEXT, ctx_attrib_list, 0);
+ } else {
+ mCurrentEglContext = EGL14.eglCreateContext(eglDisplay, mEglConfig, eglContext, ctx_attrib_list, 0);
+ }
+
+ if (mCurrentEglContext == EGL14.EGL_NO_CONTEXT) {
+ throw new RuntimeException("EGL Context Error.");
+ }
+ }
+
+
+ public void draw(int textureId, long timestamp) {
+ if (!EGL14.eglMakeCurrent(eglDisplay, eglSurface, eglSurface, mCurrentEglContext)) {
+ throw new RuntimeException("eglMakeCurrent 失败！");
+ }
+
+ if (textureId < 0) {
+ throw new RuntimeException("input texture error " + textureId);
+
+ }
+
+ mYFlipFilter.setInputTextureId(textureId);
+ mYFlipFilter.flipPosMtxY();
+ mYFlipFilter.draw(null);
+ textureId = mYFlipFilter.getOutputTextureId();
+
+ mRgba2YuvFilter.setInputTextureId(textureId);
+ mRgba2YuvFilter.draw();
+ textureId = mRgba2YuvFilter.getOutputTextureId();
+
+ mScreenRenderFilter.setInputTextureId(textureId);
+ mScreenRenderFilter.flipPosMtxY();
+ mScreenRenderFilter.draw();
+
+ EGLExt.eglPresentationTimeANDROID(eglDisplay, eglSurface, timestamp);
+ //交换数据，输出到mediacodec InputSurface中
+ EGL14.eglSwapBuffers(eglDisplay, eglSurface);
+
+ Rgba2YuvFilter.checkGlError("drawError");
+
+ }
+
+
+ public void release() {
+ EGL14.eglDestroySurface(eglDisplay, eglSurface);
+ EGL14.eglMakeCurrent(eglDisplay, eglSurface, eglSurface, mCurrentEglContext);
+ EGL14.eglDestroyContext(eglDisplay, mCurrentEglContext);
+ EGL14.eglReleaseThread();
+ EGL14.eglTerminate(eglDisplay);
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/IAlgDetector.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/IAlgDetector.java
new file mode 100644
index 000000000..2575e632b
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/IAlgDetector.java
@@ -0,0 +1,41 @@
+package com.quark.quamera.render.detector;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/1/29
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+public interface IAlgDetector {
+
+ enum State {
+ UNINITIALIZED,
+ INITIALIZED,
+ RUNNING,
+ }
+
+ enum InputDataType {
+ NV21,
+ TEXTURE
+ }
+
+ void init();
+
+ void release();
+
+ void start();
+
+ void stop();
+
+ default T detect(IAlgTextureConsumer.NV21Buffer buffer, long timestamp) {
+ return null;
+ }
+
+ InputDataType getInputDataType();
+
+
+ State getState();
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/IAlgTextureConsumer.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/IAlgTextureConsumer.java
new file mode 100644
index 000000000..bc46c41c7
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/IAlgTextureConsumer.java
@@ -0,0 +1,74 @@
+package com.quark.quamera.render.detector;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/1/29
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.opengl.EGLContext;
+
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+public interface IAlgTextureConsumer {
+
+ void updateInputTexture(EGLContext eglContext, int textureId, int width, int height, long timeStamp);
+
+ void release();
+
+ void resume();
+
+ void pause();
+
+ class NV21Buffer {
+
+ private final byte[] mBytes;
+ private final int mWidth;
+ private final int mHeight;
+ private final ReentrantReadWriteLock mLock = new ReentrantReadWriteLock();
+
+ public NV21Buffer(int width, int height) {
+ this.mWidth = width;
+ this.mHeight = height;
+ int yuv_size = (int) (width * (((float) height) * 3 / 2));
+ mBytes = new byte[yuv_size];
+ }
+
+ public int getWidth() {
+ return mWidth;
+ }
+
+ public int getHeight() {
+ return mHeight;
+ }
+
+ public byte[] readLock() {
+ mLock.readLock().lock();
+ return mBytes;
+ }
+
+ public byte[] writeLock() {
+ mLock.writeLock().lock();
+ return mBytes;
+ }
+
+ public void writeUnlock() {
+ mLock.writeLock().unlock();
+ }
+
+
+ public void readUnlock() {
+ mLock.readLock().unlock();
+ }
+
+
+ }
+
+ interface OnAlgCpuDataReceiver {
+ void onReceiveCpuData(NV21Buffer buffer, long timestamp);
+ }
+
+ void setOnAlgCpuDataReceiver(OnAlgCpuDataReceiver receiver);
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/NV21RenderExpansion.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/NV21RenderExpansion.java
new file mode 100644
index 000000000..48be077da
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/NV21RenderExpansion.java
@@ -0,0 +1,150 @@
+package com.quark.quamera.render.detector;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/12/22
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import static com.quark.quamera.render.detector.IAlgDetector.InputDataType.NV21;
+
+import android.content.Context;
+import android.opengl.EGL14;
+
+import androidx.annotation.NonNull;
+
+import com.quark.quamera.render.entry.RenderFlowData;
+import com.quark.quamera.render.expansion.IRenderExpansion;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+
+public class NV21RenderExpansion implements IRenderExpansion {
+
+ private IAlgTextureConsumer mNv21TextureConsumer;
+
+ public final ConcurrentHashMap, IAlgDetector> mDetectors = new ConcurrentHashMap<>();
+
+ public final ConcurrentHashMap, OnDetectListener> mDetectorListener = new ConcurrentHashMap<>();
+
+ private Context mContext;
+
+ public NV21RenderExpansion(Context context) {
+ mContext = context;
+ }
+
+ public interface OnDetectListener {
+ void onDetect(T result);
+
+ }
+
+ public NV21RenderExpansion addDetector(@NonNull Class clz,
+ @NonNull IAlgDetector detector) {
+ mDetectors.put(clz, detector);
+ return this;
+ }
+
+
+ private boolean isNeedNv21Stream() {
+ for (Map.Entry, IAlgDetector> entry : mDetectors.entrySet()) {
+ IAlgDetector detector = entry.getValue();
+ if (detector.getState() == IAlgDetector.State.RUNNING
+ && detector.getInputDataType() == NV21) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private AlgTextureConsumerCompat createAlgTextureConsumer(Context context) {
+ AlgTextureConsumerCompat consumer = new AlgTextureConsumerCompat(context);
+ consumer.setOnAlgCpuDataReceiver((buffer, timestamp) -> {
+ for (Map.Entry, IAlgDetector> entry : mDetectors.entrySet()) {
+ Class clz = entry.getKey();
+ IAlgDetector detector = entry.getValue();
+ if (detector.getState() == IAlgDetector.State.RUNNING) {
+ OnDetectListener listener = mDetectorListener.get(clz);
+ if (listener != null) {
+ Object result = detector.detect(buffer, timestamp);
+ //类型转换肯定没有问题
+ listener.onDetect(result);
+ }
+ }
+ }
+ });
+ return consumer;
+ }
+
+ @NonNull
+ @Override
+ public RenderFlowData render(@NonNull RenderFlowData input, long timestamp) {
+ if (isNeedNv21Stream()) {
+ if (mNv21TextureConsumer == null) {
+ mNv21TextureConsumer = createAlgTextureConsumer(mContext);
+ }
+ mNv21TextureConsumer.updateInputTexture(
+ EGL14.eglGetCurrentContext(), input.texture, input.textureWidth, input.textureHeight, timestamp);
+ }
+ return input;
+ }
+
+
+ public > void startDetector(@NonNull Class clz, OnDetectListener detectListener) {
+ IAlgDetector detector = mDetectors.get(clz);
+ if (detector == null) {
+ throw new IllegalArgumentException("No support detect " + clz);
+ }
+ if (detector.getState() == IAlgDetector.State.UNINITIALIZED) {
+ detector.init();
+ }
+
+ detector.start();
+
+ if (detectListener != null) {
+ mDetectorListener.put(clz, detectListener);
+ }
+ }
+
+ public > void stopDetector(@NonNull Class clz) {
+ IAlgDetector detector = mDetectors.get(clz);
+ if (detector == null) {
+ throw new IllegalArgumentException("No support detect " + clz);
+ }
+ detector.stop();
+ }
+
+ public void release() {
+ for (Map.Entry, IAlgDetector> entry : mDetectors.entrySet()) {
+ IAlgDetector detector = entry.getValue();
+ detector.release();
+ }
+ }
+
+
+ public > T getDetector(Class clz) {
+ IAlgDetector detector = mDetectors.get(clz);
+ if (detector == null) {
+ throw new IllegalArgumentException("No support detect " + clz);
+ }
+ return (T) detector;
+ }
+
+ @Override
+ public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+ if (mNv21TextureConsumer == null) {
+ mNv21TextureConsumer = createAlgTextureConsumer(mContext);
+ }
+ }
+
+ @Override
+ public void onSurfaceDestroy() {
+ if (mNv21TextureConsumer != null) {
+ mNv21TextureConsumer.release();
+ mNv21TextureConsumer = null;
+ }
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/RenderExpansionManager.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/RenderExpansionManager.java
new file mode 100644
index 000000000..e71b13744
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/RenderExpansionManager.java
@@ -0,0 +1,155 @@
+package com.quark.quamera.render.detector;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/1/29
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import static com.quark.quamera.render.detector.IAlgDetector.InputDataType.NV21;
+
+import android.content.Context;
+import android.opengl.EGL14;
+
+import androidx.annotation.NonNull;
+
+import com.quark.quamera.render.entry.RenderFlowData;
+import com.quark.quamera.render.expansion.IRenderExpansion;
+import com.quark.quamera.util.CameraShould;
+import com.quark.quamera.util.CollectionUtil;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+
+public class RenderExpansionManager implements IRenderExpansion {
+
+
+ private final LinkedHashMap, IRenderExpansion> mRenderExpansions = new LinkedHashMap<>();
+
+ private final Executor mGLExecutor;
+
+ private final Context mContext;
+
+ private SurfaceCreateEventHolder mSurfaceCreateEventHolder;
+
+ private SurfaceChangeEventHolder mSurfaceChangeEventHolder;
+
+ public synchronized RenderExpansionManager addRenderExpansion(Class clz, @NonNull T renderExpansion) {
+ CameraShould.beTrue(renderExpansion != null);
+ renderExpansion.setGLExecutor(mGLExecutor);
+ if (mRenderExpansions.containsValue(renderExpansion)) {
+ CameraShould.fail("add the same expansion multiply times");
+ return this;
+ }
+
+ mRenderExpansions.put(clz, renderExpansion);
+
+ notifyMissSurfaceEvent(renderExpansion);
+
+ return this;
+ }
+
+ private void notifyMissSurfaceEvent(@NonNull IRenderExpansion expansion) {
+ if (mSurfaceCreateEventHolder != null || mSurfaceChangeEventHolder != null) {
+ mGLExecutor.execute(() -> {
+ //double check in gl thread
+ if (mSurfaceCreateEventHolder != null) {
+ expansion.onSurfaceCreated(mSurfaceCreateEventHolder.gl, mSurfaceCreateEventHolder.config);
+ }
+ //double check in gl thread
+ if (mSurfaceChangeEventHolder != null) {
+ expansion.onSurfaceChanged(mSurfaceChangeEventHolder.gl, mSurfaceChangeEventHolder.width, mSurfaceChangeEventHolder.height);
+ }
+ });
+ }
+ }
+
+
+ public RenderExpansionManager(Context context, Executor executor) {
+ mContext = context;
+ mGLExecutor = executor;
+ }
+
+
+ @NonNull
+ @Override
+ public RenderFlowData render(@NonNull RenderFlowData input, long timestamp) {
+ RenderFlowData lastResult = input;
+ for (IRenderExpansion expansion : mRenderExpansions.values()) {
+ RenderFlowData temp = expansion.render(lastResult, timestamp);
+ if (temp.texture >= 0 && lastResult != temp) {
+ lastResult.recycle();
+ lastResult = temp;
+ }
+ }
+ return lastResult;
+ }
+
+
+ private static class SurfaceLifeEventHolder {
+ GL10 gl;
+
+ public SurfaceLifeEventHolder(GL10 gl) {
+ this.gl = gl;
+ }
+ }
+
+ private static class SurfaceCreateEventHolder extends SurfaceLifeEventHolder {
+ EGLConfig config;
+
+ public SurfaceCreateEventHolder(GL10 gl, EGLConfig config) {
+ super(gl);
+ this.config = config;
+ }
+ }
+
+ private static class SurfaceChangeEventHolder extends SurfaceLifeEventHolder {
+ int width;
+ int height;
+
+ public SurfaceChangeEventHolder(GL10 gl, int width, int height) {
+ super(gl);
+ this.width = width;
+ this.height = height;
+ }
+ }
+
+
+ @Override
+ public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+ mSurfaceCreateEventHolder = new SurfaceCreateEventHolder(gl, config);
+ synchronized (mRenderExpansions) {
+ CollectionUtil.forEach(mRenderExpansions.values(), expansion -> expansion.onSurfaceCreated(gl, config));
+ }
+ }
+
+ @Override
+ public void onSurfaceChanged(GL10 gl, int width, int height) {
+ mSurfaceChangeEventHolder = new SurfaceChangeEventHolder(gl, width, height);
+ synchronized (mRenderExpansions) {
+ CollectionUtil.forEach(mRenderExpansions.values(), expansion -> expansion.onSurfaceChanged(gl, width, height));
+ }
+ }
+
+ @Override
+ public void onSurfaceDestroy() {
+ mSurfaceChangeEventHolder = null;
+ mSurfaceCreateEventHolder = null;
+ synchronized (mRenderExpansions) {
+ CollectionUtil.forEach(mRenderExpansions.values(), IRenderExpansion::onSurfaceDestroy);
+ }
+ }
+
+
+ public T getRenderExpansion(Class clz) {
+ return (T) mRenderExpansions.get(clz);
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/Rgba2YuvFilter.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/Rgba2YuvFilter.java
new file mode 100644
index 000000000..673977a72
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/detector/Rgba2YuvFilter.java
@@ -0,0 +1,297 @@
+package com.quark.quamera.render.detector;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/1/26
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.content.Context;
+import android.opengl.GLES20;
+import android.util.Log;
+
+
+import com.quark.quamera.R;
+import com.quark.quamera.render.IGLFilter;
+import com.quark.quamera.util.GlCommonUtil;
+import com.quark.quamera.util.MatrixUtils;
+import com.quark.quamera.util.OpenGlUtils;
+
+import java.nio.FloatBuffer;
+import java.util.Locale;
+
+import static android.opengl.GLES10.GL_NO_ERROR;
+
+public class Rgba2YuvFilter implements IGLFilter {
+
+
+ public static String RGBA_2_YUV_FRAGMENT = null;
+ public static String RGBA_2_YUV_VERTEX = null;
+
+
+ private final FloatBuffer mVtxBuf = OpenGlUtils.createSquareVtx();
+ private final float[] mIdentityMtx = OpenGlUtils.createIdentityMtx();
+
+ protected int mInputTextureId = -1;
+
+ private final int[] mTexId = new int[]{0};
+
+ private int mFboId = -1;
+// private int mRboId = -1;
+
+ protected int mInputWidth = -1;
+ protected int mInputHeight = -1;
+
+ protected int mOutputWidth = -1;
+ protected int mOutputHeight = -1;
+
+ private boolean mPrepared = false;
+
+ private final Context mContext;
+
+ public Rgba2YuvFilter(Context context) {
+ mContext = context;
+ }
+
+
+ public void setInputSize(int width, int height) {
+ mInputWidth = width;
+ mInputHeight = height;
+ mOutputWidth = mInputWidth;
+ mOutputHeight = mInputHeight;
+ }
+
+ public int getOutputWidth() {
+ return mOutputWidth;
+ }
+
+ public int getOutputHeight() {
+ return mOutputHeight;
+ }
+
+ public void clear() {
+ GLES20.glClearColor(0f, 0f, 0f, 1f);
+ GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
+ }
+
+ public void prepare() {
+ Log.d("e", "prepare createFrameBuffer" + mPrepared + ", width " + mInputWidth + ", height" + mInputHeight);
+ if (mPrepared) {
+ return;
+ }
+
+ loadShaderAndParams();
+ createEffectTexture();
+ mPrepared = true;
+ }
+
+ public void setInputTextureId(int textureId) {
+ mInputTextureId = textureId;
+ }
+
+
+ private int mMVPHandler = -1;
+ private int mInputImageTextureWidthHandler = -1;
+ private int mInputImageTextureHeightHandler = -1;
+ private int mProgram = -1;
+ private int mPositionHandle = -1;
+ private int mInputTexCoordHandle = -1;
+
+
+ private void loadShaderAndParams() {
+
+ if (RGBA_2_YUV_VERTEX == null) {
+ RGBA_2_YUV_VERTEX = OpenGlUtils.readRawShaderFile(mContext, R.raw.rgba_2_yuv_vertex);
+ }
+
+ if (RGBA_2_YUV_FRAGMENT == null) {
+ RGBA_2_YUV_FRAGMENT = OpenGlUtils.readRawShaderFile(mContext, R.raw.rbga_2_yuv_frag);
+ }
+
+ checkGlError("initSH_S");
+
+ mProgram = GlCommonUtil.createProgram(RGBA_2_YUV_VERTEX, RGBA_2_YUV_FRAGMENT);
+
+ if (mProgram == 0) {
+ //TODO 错误码
+ }
+
+ mInputTexCoordHandle = GLES20.glGetAttribLocation(mProgram, "inputTextureCoordinate");
+ mPositionHandle = GLES20.glGetAttribLocation(mProgram, "position");
+
+ mMVPHandler = GLES20.glGetUniformLocation(mProgram, "mvp");
+ mInputImageTextureWidthHandler = GLES20.glGetUniformLocation(mProgram, "inputImageTextureWidth");
+ mInputImageTextureHeightHandler = GLES20.glGetUniformLocation(mProgram, "inputImageTextureHeight");
+
+ checkGlError("initSH_E");
+ }
+
+ public int getInputWidth() {
+ return mInputWidth;
+ }
+
+ public int getInputHeight() {
+ return mInputHeight;
+ }
+
+ private void createEffectTexture() {
+ if (mInputWidth <= 0 || mInputHeight <= 0) {
+ return;
+ }
+ checkGlError("initFBO_S");
+ createFrameBuffer();
+ GLES20.glGenTextures(1, mTexId, 0);
+
+// GLES20.glBindRenderbuffer(GLES20.GL_RENDERBUFFER, mRboId);
+// GLES20.glRenderbufferStorage(GLES20.GL_RENDERBUFFER,
+// GLES20.GL_DEPTH_COMPONENT16, mOutputWidth, mOutputHeight);
+
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mFboId);
+// GLES20.glFramebufferRenderbuffer(GLES20.GL_FRAMEBUFFER,
+// GLES20.GL_DEPTH_ATTACHMENT, GLES20.GL_RENDERBUFFER, mRboId);
+
+ GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTexId[0]);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
+
+ GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA,
+ mOutputWidth, mOutputHeight, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);
+
+ GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER,
+ GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, mTexId[0], 0);
+
+ if (GLES20.glCheckFramebufferStatus(GLES20.GL_FRAMEBUFFER) !=
+ GLES20.GL_FRAMEBUFFER_COMPLETE) {
+ throw new RuntimeException("glCheckFramebufferStatus()");
+ }
+ checkGlError("initFBO_E");
+ }
+
+
+ public int getOutputTextureId() {
+ return mTexId[0];
+ }
+
+
+ public void draw() {
+ if (-1 == mProgram
+ || mInputTextureId == -1
+ || mInputWidth == -1
+ || mInputHeight == -1) {
+ return;
+ }
+
+ checkGlError("draw_S");
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, mFboId);
+
+ checkGlError("draw_S");
+
+ GLES20.glViewport(0, 0, mOutputWidth, mOutputHeight);
+
+ checkGlError("draw_S");
+
+ GLES20.glClearColor(0f, 1f, 0f, 1f);
+ GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
+
+ GLES20.glUseProgram(mProgram);
+
+ mVtxBuf.position(0);
+ GLES20.glVertexAttribPointer(mPositionHandle, 3, GLES20.GL_FLOAT, false, 4 * (3 + 2), mVtxBuf);
+ GLES20.glEnableVertexAttribArray(mPositionHandle);
+
+ checkGlError("draw_S");
+
+ mVtxBuf.position(3);
+ GLES20.glVertexAttribPointer(mInputTexCoordHandle, 2, GLES20.GL_FLOAT, false, 4 * (3 + 2), mVtxBuf);
+ GLES20.glEnableVertexAttribArray(mInputTexCoordHandle);
+
+ checkGlError("draw_S");
+
+ GLES20.glUniform1f(mInputImageTextureHeightHandler, mInputHeight);
+ GLES20.glUniform1f(mInputImageTextureWidthHandler, mInputWidth);
+
+
+ GLES20.glUniformMatrix4fv(mMVPHandler, 1, false, mIdentityMtx, 0);
+
+ checkGlError("draw_S");
+
+ GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mInputTextureId);
+
+ checkGlError("draw_S");
+
+ GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
+
+ checkGlError("draw_S");
+
+ GLES20.glDisableVertexAttribArray(mPositionHandle);
+ GLES20.glDisableVertexAttribArray(mInputTexCoordHandle);
+ GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+ GLES20.glUseProgram(0);
+
+ checkGlError("draw_E");
+ }
+
+ public static void checkGlError(String op) {
+ int errorCode = GLES20.glGetError();
+ if (errorCode != GL_NO_ERROR) {
+ throw new IllegalStateException(String.format(Locale.CHINA, "GL Error when %s with code %d ", op, errorCode));
+ }
+ }
+
+
+ private void createFrameBuffer() {
+ int[] fboId = new int[]{0};
+ int[] rboId = new int[]{0};
+ GLES20.glGenFramebuffers(1, fboId, 0);
+ GLES20.glGenRenderbuffers(1, rboId, 0);
+ mFboId = fboId[0];
+// mRboId = rboId[0];
+ Log.d("e", "createFrameBuffer: ");
+ }
+
+ private void releaseFrameBuffer() {
+ if (mFboId != -1) {
+ int[] fboId = new int[]{mFboId};
+ GLES20.glDeleteFramebuffers(1, fboId, 0);
+ mFboId = -1;
+ }
+// if (mRboId != -1) {
+// int[] rboId = new int[]{mRboId};
+// GLES20.glDeleteRenderbuffers(1, rboId, 0);
+// mRboId = -1;
+// }
+ }
+
+ private void releaseProgram() {
+ if (mProgram == -1) {
+ return;
+ }
+ GLES20.glDeleteProgram(mProgram);
+ }
+
+ public void release() {
+ releaseTexture();
+ releaseFrameBuffer();
+ releaseProgram();
+ }
+
+ public void releaseTexture(){
+ if (mTexId[0] > 0) {
+ GlCommonUtil.deleteGLTexture(mTexId);
+ }
+ }
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/entry/FrameDetectData.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/entry/FrameDetectData.java
new file mode 100644
index 000000000..6bd1681b9
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/entry/FrameDetectData.java
@@ -0,0 +1,35 @@
+package com.quark.quamera.render.entry;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/3/15
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+public class FrameDetectData {
+
+ public float[] points ;
+
+// private Object mData;
+// private TYPE mType;
+// private long mTimestamp;
+//
+// public FrameDetectData(TYPE type, Object data, long timestamp) {
+// mType = type;
+// mData = data;
+// mTimestamp = timestamp;
+// }
+//
+// public enum TYPE {
+// FLOAT_ARRAY,
+// }
+//
+// public Object getData() {
+// return mData;
+// }
+//
+// public TYPE getType() {
+// return mType;
+// }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/entry/RenderFlowData.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/entry/RenderFlowData.java
new file mode 100644
index 000000000..66f72624d
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/entry/RenderFlowData.java
@@ -0,0 +1,69 @@
+//
+// Source code recreated from a .class file by IntelliJ IDEA
+// (powered by Fernflower decompiler)
+//
+
+package com.quark.quamera.render.entry;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+
+public class RenderFlowData {
+
+ public int texture = -1;
+ public int textureWidth;
+ public int textureHeight;
+ public int windowHeight;
+ public int windowWidth;
+
+ public final FrameDetectData detectData = new FrameDetectData();
+
+ public final HashMap extraData = new HashMap<>();
+
+
+ private RenderFlowData(int windowWidth, int windowHeight) {
+ this.windowHeight = windowHeight;
+ this.windowWidth = windowWidth;
+ }
+
+ public void fillExtraData(RenderFlowData data) {
+ data.extraData.putAll(extraData);
+ }
+
+ private final static LinkedList sCacheQueue = new LinkedList<>();
+
+ public void recycle() {
+ texture = -1;
+ textureWidth = 0;
+ textureHeight = 0;
+ windowHeight = 0;
+ windowWidth = 0;
+ extraData.clear();
+ detectData.points = null;
+
+ synchronized (sCacheQueue) {
+ if (sCacheQueue.size() < 100) {
+ sCacheQueue.add(this);
+ }
+ }
+ }
+
+ public static RenderFlowData obtain(int windowWidth, int windowHeight, HashMap extra) {
+ RenderFlowData data;
+ synchronized (sCacheQueue) {
+ if (sCacheQueue.size() > 0) {
+ data = sCacheQueue.remove();
+ data.windowHeight = windowHeight;
+ data.windowWidth = windowWidth;
+ } else {
+ data = new RenderFlowData(windowWidth, windowHeight);
+ }
+ }
+ if (extra != null) {
+ data.extraData.putAll(extra);
+ }
+ return data;
+ }
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/expansion/GLThread.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/expansion/GLThread.java
new file mode 100644
index 000000000..edc929b0d
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/expansion/GLThread.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.quark.quamera.render.expansion;
+
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+
+@Documented
+@Retention(CLASS)
+@Target({METHOD, CONSTRUCTOR, TYPE, PARAMETER})
+public @interface GLThread {
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/expansion/IAlgDetectRender.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/expansion/IAlgDetectRender.java
new file mode 100644
index 000000000..9ba03c107
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/expansion/IAlgDetectRender.java
@@ -0,0 +1,14 @@
+package com.quark.quamera.render.expansion;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/3/15
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import com.quark.quamera.render.entry.FrameDetectData;
+
+public interface IAlgDetectRender {
+ FrameDetectData getDetectData();
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/expansion/IRenderExpansion.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/expansion/IRenderExpansion.java
new file mode 100644
index 000000000..cd7824fc1
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/expansion/IRenderExpansion.java
@@ -0,0 +1,50 @@
+package com.quark.quamera.render.expansion;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/2/25
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import androidx.annotation.NonNull;
+
+import com.quark.quamera.render.entry.RenderFlowData;
+
+import java.util.concurrent.Executor;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+
+public interface IRenderExpansion {
+
+
+ default void onSurfaceCreated(GL10 gl, EGLConfig config) {
+ }
+
+ default void onSurfaceChanged(GL10 gl, int width, int height) {
+
+ }
+
+ default void setGLExecutor(Executor GLExecutor) {
+ }
+
+ default Executor getGLExecutor() {
+ return null;
+ }
+
+
+ default boolean needRender() {
+ return true;
+ }
+
+ @GLThread
+ @NonNull
+ RenderFlowData render(@NonNull RenderFlowData input, long timestamp);
+
+
+ @GLThread
+ void onSurfaceDestroy();
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/expansion/RenderExpansion.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/expansion/RenderExpansion.java
new file mode 100644
index 000000000..ef0ce2d77
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/expansion/RenderExpansion.java
@@ -0,0 +1,16 @@
+package com.quark.quamera.render.expansion;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/12/15
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+
+public abstract class RenderExpansion implements IRenderExpansion {
+
+
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/photo/ExportPhoto.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/photo/ExportPhoto.java
new file mode 100644
index 000000000..fd5f5d0d8
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/photo/ExportPhoto.java
@@ -0,0 +1,123 @@
+//
+// Source code recreated from a .class file by IntelliJ IDEA
+// (powered by Fernflower decompiler)
+//
+
+package com.quark.quamera.render.photo;
+
+import android.graphics.Bitmap;
+
+import com.quark.quamera.render.entry.FrameDetectData;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ExportPhoto {
+ public int width;
+ public int height;
+ public byte[] data;
+ public ExportPhoto.ImageType dataType;
+ public Bitmap bitmap;
+ public int rotation;
+ private boolean hasClip = false;
+
+ private SnapShotCommand mSnapShotCommand;
+ public FrameDetectData mFrameDetectData;
+
+ private final List mSubPhotos = new ArrayList<>();
+
+ public ExportPhoto(int w, int h, byte[] dataIn) {
+ this.width = w;
+ this.height = h;
+ this.data = dataIn;
+ this.dataType = ExportPhoto.ImageType.RGBA_8888;
+ }
+
+ public void setRotation(int rotation) {
+ this.rotation = rotation;
+ }
+
+ public ExportPhoto setHasClip(boolean hasClip) {
+ this.hasClip = hasClip;
+ return this;
+ }
+
+ public boolean isHasClip() {
+ return this.hasClip;
+ }
+
+ public ExportPhoto(int width, int height, byte[] data, ExportPhoto.ImageType imageType) {
+ this.width = width;
+ this.height = height;
+ this.data = data;
+ this.dataType = imageType;
+ }
+
+ public ExportPhoto(int width, int height, Bitmap bitmap) {
+ this.width = width;
+ this.height = height;
+ this.bitmap = bitmap;
+ this.dataType = ExportPhoto.ImageType.BITMAP;
+ }
+
+ public static ExportPhoto ofJPEG(byte[] data) {
+ if (data == null) {
+ return null;
+ } else {
+ ExportPhoto result = new ExportPhoto(0, 0, data);
+ result.dataType = ExportPhoto.ImageType.JPEG_DATA;
+ return result;
+ }
+ }
+
+ public static ExportPhoto ofBitmap(Bitmap bitmap) {
+ return bitmap == null ? null : new ExportPhoto(bitmap.getWidth(), bitmap.getHeight(), bitmap);
+ }
+
+ public boolean isValid() {
+ if (this.dataType == ExportPhoto.ImageType.RGBA_8888) {
+ return this.data != null && this.width > 0 && this.height > 0;
+ } else if (this.dataType == ExportPhoto.ImageType.JPEG_DATA) {
+ return this.data != null;
+ } else if (this.dataType == ExportPhoto.ImageType.BITMAP) {
+ return this.bitmap != null;
+ } else {
+ return false;
+ }
+ }
+
+
+ public ExportPhoto setFrameDetectData(FrameDetectData frameDetectData) {
+ mFrameDetectData = frameDetectData;
+ return this;
+ }
+
+ public ExportPhoto setSnapShotCommand(SnapShotCommand snapShotCommand) {
+ mSnapShotCommand = snapShotCommand;
+ return this;
+ }
+
+ public SnapShotCommand getSnapShotCommand() {
+ return mSnapShotCommand;
+ }
+
+ public ExportPhoto addSubPhoto(ExportPhoto photo) {
+ mSubPhotos.add(photo);
+ return this;
+ }
+
+ public List getSubPhotos() {
+ return mSubPhotos;
+ }
+
+
+ public static enum ImageType {
+ RGBA_8888,
+ YUV_NV21,
+ JPEG_DATA,
+ BITMAP;
+
+ private ImageType() {
+ }
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/photo/SnapShotCommand.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/photo/SnapShotCommand.java
new file mode 100644
index 000000000..1859a509a
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/photo/SnapShotCommand.java
@@ -0,0 +1,113 @@
+//
+// Source code recreated from a .class file by IntelliJ IDEA
+// (powered by Fernflower decompiler)
+//
+
+package com.quark.quamera.render.photo;
+
+import android.graphics.Matrix;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.webkit.ValueCallback;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.List;
+
+public class SnapShotCommand {
+ private Object mTag;
+ private float mLeft = 0.0F;
+ private float mTop = 0.0F;
+ private float mWith = 1.0F;
+ private float mHeight = 1.0F;
+ private float mScale = 1f;
+ private float mRotation = 0;
+ private final ValueCallback mCallback;
+ private static final Matrix mGLCoordinateMatrix = new Matrix();
+ private static final RectF mTempRect = new RectF();
+
+ private final List mSubCommand = new ArrayList<>();
+
+ public SnapShotCommand(float left, float top, float with, float height, ValueCallback callback) {
+ this.mLeft = left;
+ this.mTop = top;
+ this.mWith = with;
+ this.mHeight = height;
+ this.mCallback = callback;
+ }
+
+ public synchronized SnapShotCommand addSubCommand(SnapShotCommand command) {
+ mSubCommand.add(command);
+ return this;
+ }
+
+ public synchronized List getSubCommand() {
+ return mSubCommand;
+ }
+
+ public void set(float left, float top, float with, float height) {
+ this.mLeft = left;
+ this.mTop = top;
+ this.mWith = with;
+ this.mHeight = height;
+ }
+
+ public SnapShotCommand(ValueCallback callback) {
+ this.mCallback = callback;
+ }
+
+ public ValueCallback getCallback() {
+ return this.mCallback;
+ }
+
+ public boolean needClip() {
+ if (this.mLeft >= 0.0F && this.mTop >= 0.0F && this.mWith >= 0.0F && this.mWith + this.mLeft <= 1.0F && this.mHeight >= 0.0F && this.mHeight + this.mTop <= 1.0F) {
+ return this.mLeft > 0.0F || this.mTop > 0.0F || this.mWith < 1.0F || this.mHeight < 1.0F;
+ } else {
+ return false;
+ }
+ }
+
+ public float getScale() {
+ return mScale;
+ }
+
+ public SnapShotCommand setScale(float scale) {
+ mScale = scale;
+ return this;
+ }
+
+ public void setRotation(float rotation) {
+ mRotation = rotation;
+ }
+
+ public SnapShotCommand setTag(Object tag) {
+ mTag = tag;
+ return this;
+ }
+
+ public Object getTag() {
+ return mTag;
+ }
+
+ public Rect getGLSnapshotRect(int pixelWidth, int pixelHeight, boolean needFlipY) {
+ if (!this.needClip()) {
+ return new Rect(0, 0, pixelWidth, pixelHeight);
+ } else if (needFlipY) {
+ mGLCoordinateMatrix.reset();
+ mGLCoordinateMatrix.postTranslate(-0.5F, -0.5F);
+ mGLCoordinateMatrix.postScale(1.0F, -1.0F);
+ mGLCoordinateMatrix.postTranslate(0.5F, 0.5F);
+ mGLCoordinateMatrix.postScale((float) pixelWidth, (float) pixelHeight);
+ mTempRect.set(this.mLeft, this.mTop, this.mWith + this.mLeft, this.mHeight + this.mTop);
+ mGLCoordinateMatrix.mapRect(mTempRect);
+ return new Rect((int) mTempRect.left, (int) mTempRect.top, (int) mTempRect.right, (int) mTempRect.bottom);
+ } else {
+ mGLCoordinateMatrix.reset();
+ mGLCoordinateMatrix.postScale((float) pixelWidth, (float) pixelHeight);
+ mTempRect.set(this.mLeft, this.mTop, this.mWith + this.mLeft, this.mHeight + this.mTop);
+ mGLCoordinateMatrix.mapRect(mTempRect);
+ return new Rect((int) mTempRect.left, (int) mTempRect.top, (int) mTempRect.right, (int) mTempRect.bottom);
+ }
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/view/AndroidGLSurfaceView.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/view/AndroidGLSurfaceView.java
new file mode 100644
index 000000000..590cbee4a
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/view/AndroidGLSurfaceView.java
@@ -0,0 +1,1982 @@
+package com.quark.quamera.render.view;
+
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+import android.content.Context;
+import android.opengl.EGL14;
+import android.opengl.EGLExt;
+import android.opengl.GLDebugHelper;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+import java.io.Writer;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+
+import javax.microedition.khronos.egl.EGL10;
+import javax.microedition.khronos.egl.EGL11;
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.egl.EGLContext;
+import javax.microedition.khronos.egl.EGLDisplay;
+import javax.microedition.khronos.egl.EGLSurface;
+import javax.microedition.khronos.opengles.GL;
+import javax.microedition.khronos.opengles.GL10;
+
+/**
+ * An implementation of SurfaceView that uses the dedicated surface for
+ * displaying OpenGL rendering.
+ *
+ * A GLSurfaceView provides the following features:
+ *
+ *
+ * - Manages a surface, which is a special piece of memory that can be
+ * composited into the Android view system.
+ *
- Manages an EGL display, which enables OpenGL to render into a surface.
+ *
- Accepts a user-provided Renderer object that does the actual rendering.
+ *
- Renders on a dedicated thread to decouple rendering performance from the
+ * UI thread.
+ *
- Supports both on-demand and continuous rendering.
+ *
- Optionally wraps, traces, and/or error-checks the renderer's OpenGL calls.
+ *
+ *
+ *
+ *
Developer Guides
+ *
For more information about how to use OpenGL, read the
+ * OpenGL developer guide.
+ *
Using GLSurfaceView
+ *
+ * Typically you use GLSurfaceView by subclassing it and overriding one or more of the
+ * View system input event methods. If your application does not need to override event
+ * methods then GLSurfaceView can be used as-is. For the most part
+ * GLSurfaceView behavior is customized by calling "set" methods rather than by subclassing.
+ * For example, unlike a regular View, drawing is delegated to a separate Renderer object which
+ * is registered with the GLSurfaceView
+ * using the {@link #setRenderer(Renderer)} call.
+ *
+ *
Initializing GLSurfaceView
+ * All you have to do to initialize a GLSurfaceView is call {@link #setRenderer(Renderer)}.
+ * However, if desired, you can modify the default behavior of GLSurfaceView by calling one or
+ * more of these methods before calling setRenderer:
+ *
+ * - {@link #setDebugFlags(int)}
+ *
- {@link #setEGLConfigChooser(boolean)}
+ *
- {@link #setEGLConfigChooser(EGLConfigChooser)}
+ *
- {@link #setEGLConfigChooser(int, int, int, int, int, int)}
+ *
- {@link #setGLWrapper(GLWrapper)}
+ *
+ *
+ *
Specifying the android.view.Surface
+ * By default GLSurfaceView will create a PixelFormat.RGB_888 format surface. If a translucent
+ * surface is required, call getHolder().setFormat(PixelFormat.TRANSLUCENT).
+ * The exact format of a TRANSLUCENT surface is device dependent, but it will be
+ * a 32-bit-per-pixel surface with 8 bits per component.
+ *
+ *
Choosing an EGL Configuration
+ * A given Android device may support multiple EGLConfig rendering configurations.
+ * The available configurations may differ in how many channels of data are present, as
+ * well as how many bits are allocated to each channel. Therefore, the first thing
+ * GLSurfaceView has to do when starting to render is choose what EGLConfig to use.
+ *
+ * By default GLSurfaceView chooses a EGLConfig that has an RGB_888 pixel format,
+ * with at least a 16-bit depth buffer and no stencil.
+ *
+ * If you would prefer a different EGLConfig
+ * you can override the default behavior by calling one of the
+ * setEGLConfigChooser methods.
+ *
+ *
Debug Behavior
+ * You can optionally modify the behavior of GLSurfaceView by calling
+ * one or more of the debugging methods {@link #setDebugFlags(int)},
+ * and {@link #setGLWrapper}. These methods may be called before and/or after setRenderer, but
+ * typically they are called before setRenderer so that they take effect immediately.
+ *
+ *
Setting a Renderer
+ * Finally, you must call {@link #setRenderer} to register a {@link Renderer}.
+ * The renderer is
+ * responsible for doing the actual OpenGL rendering.
+ *
+ *
Rendering Mode
+ * Once the renderer is set, you can control whether the renderer draws
+ * continuously or on-demand by calling
+ * {@link #setRenderMode}. The default is continuous rendering.
+ *
+ *
Activity Life-cycle
+ * A GLSurfaceView must be notified when to pause and resume rendering. GLSurfaceView clients
+ * are required to call {@link #onPause()} when the activity stops and
+ * {@link #onResume()} when the activity starts. These calls allow GLSurfaceView to
+ * pause and resume the rendering thread, and also allow GLSurfaceView to release and recreate
+ * the OpenGL display.
+ *
+ *
Handling events
+ *
+ * To handle an event you will typically subclass GLSurfaceView and override the
+ * appropriate method, just as you would with any other View. However, when handling
+ * the event, you may need to communicate with the Renderer object
+ * that's running in the rendering thread. You can do this using any
+ * standard Java cross-thread communication mechanism. In addition,
+ * one relatively easy way to communicate with your renderer is
+ * to call
+ * {@link #queueEvent(Runnable)}. For example:
+ *
+ * class MyGLSurfaceView extends GLSurfaceView {
+ *
+ * private MyRenderer mMyRenderer;
+ *
+ * public void start() {
+ * mMyRenderer = ...;
+ * setRenderer(mMyRenderer);
+ * }
+ *
+ * public boolean onKeyDown(int keyCode, KeyEvent event) {
+ * if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
+ * queueEvent(new Runnable() {
+ * // This method will be called on the rendering
+ * // thread:
+ * public void run() {
+ * mMyRenderer.handleDpadCenter();
+ * }});
+ * return true;
+ * }
+ * return super.onKeyDown(keyCode, event);
+ * }
+ * }
+ *
+ *
+ */
+public class AndroidGLSurfaceView extends SurfaceView implements SurfaceHolder.Callback2 {
+ private final static String TAG = "GLSurfaceView";
+ private final static boolean LOG_ATTACH_DETACH = true;
+ private final static boolean LOG_THREADS = true;
+ private final static boolean LOG_PAUSE_RESUME = true;
+ private final static boolean LOG_SURFACE = true;
+ private final static boolean LOG_RENDERER = false;
+ private final static boolean LOG_RENDERER_DRAW_FRAME = false;
+ private final static boolean LOG_EGL = true;
+ /**
+ * The renderer only renders
+ * when the surface is created, or when {@link #requestRender} is called.
+ *
+ * @see #getRenderMode()
+ * @see #setRenderMode(int)
+ * @see #requestRender()
+ */
+ public final static int RENDERMODE_WHEN_DIRTY = 0;
+ /**
+ * The renderer is called
+ * continuously to re-render the scene.
+ *
+ * @see #getRenderMode()
+ * @see #setRenderMode(int)
+ */
+ public final static int RENDERMODE_CONTINUOUSLY = 1;
+
+ /**
+ * Check glError() after every GL call and throw an exception if glError indicates
+ * that an error has occurred. This can be used to help track down which OpenGL ES call
+ * is causing an error.
+ *
+ * @see #getDebugFlags
+ * @see #setDebugFlags
+ */
+ public final static int DEBUG_CHECK_GL_ERROR = 1;
+
+ /**
+ * Log GL calls to the system log at "verbose" level with tag "GLSurfaceView".
+ *
+ * @see #getDebugFlags
+ * @see #setDebugFlags
+ */
+ public final static int DEBUG_LOG_GL_CALLS = 2;
+
+ /**
+ * Standard View constructor. In order to render something, you
+ * must call {@link #setRenderer} to register a renderer.
+ */
+ public AndroidGLSurfaceView(Context context) {
+ super(context);
+ init();
+ }
+
+ /**
+ * Standard View constructor. In order to render something, you
+ * must call {@link #setRenderer} to register a renderer.
+ */
+ public AndroidGLSurfaceView(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ init();
+ }
+
+ @Override
+ protected void finalize() throws Throwable {
+ try {
+ if (mGLThread != null) {
+ // GLThread may still be running if this view was never
+ // attached to a window.
+ mGLThread.requestExitAndWait();
+ }
+ } finally {
+ super.finalize();
+ }
+ }
+
+ private void init() {
+ // Install a SurfaceHolder.Callback so we get notified when the
+ // underlying surface is created and destroyed
+ SurfaceHolder holder = getHolder();
+ holder.addCallback(this);
+ // setFormat is done by SurfaceView in SDK 2.3 and newer. Uncomment
+ // this statement if back-porting to 2.2 or older:
+ // holder.setFormat(PixelFormat.RGB_565);
+ //
+ // setType is not needed for SDK 2.0 or newer. Uncomment this
+ // statement if back-porting this code to older SDKs.
+ // holder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
+ }
+
+ /**
+ * Set the glWrapper. If the glWrapper is not null, its
+ * {@link GLWrapper#wrap(GL)} method is called
+ * whenever a surface is created. A GLWrapper can be used to wrap
+ * the GL object that's passed to the renderer. Wrapping a GL
+ * object enables examining and modifying the behavior of the
+ * GL calls made by the renderer.
+ *
+ * Wrapping is typically used for debugging purposes.
+ *
+ * The default value is null.
+ * @param glWrapper the new GLWrapper
+ */
+ public void setGLWrapper(GLWrapper glWrapper) {
+ mGLWrapper = glWrapper;
+ }
+
+ /**
+ * Set the debug flags to a new value. The value is
+ * constructed by OR-together zero or more
+ * of the DEBUG_CHECK_* constants. The debug flags take effect
+ * whenever a surface is created. The default value is zero.
+ * @param debugFlags the new debug flags
+ * @see #DEBUG_CHECK_GL_ERROR
+ * @see #DEBUG_LOG_GL_CALLS
+ */
+ public void setDebugFlags(int debugFlags) {
+ mDebugFlags = debugFlags;
+ }
+
+ /**
+ * Get the current value of the debug flags.
+ * @return the current value of the debug flags.
+ */
+ public int getDebugFlags() {
+ return mDebugFlags;
+ }
+
+ /**
+ * Control whether the EGL context is preserved when the GLSurfaceView is paused and
+ * resumed.
+ *
+ * If set to true, then the EGL context may be preserved when the GLSurfaceView is paused.
+ *
+ * Prior to API level 11, whether the EGL context is actually preserved or not
+ * depends upon whether the Android device can support an arbitrary number of
+ * EGL contexts or not. Devices that can only support a limited number of EGL
+ * contexts must release the EGL context in order to allow multiple applications
+ * to share the GPU.
+ *
+ * If set to false, the EGL context will be released when the GLSurfaceView is paused,
+ * and recreated when the GLSurfaceView is resumed.
+ *
+ *
+ * The default is false.
+ *
+ * @param preserveOnPause preserve the EGL context when paused
+ */
+ public void setPreserveEGLContextOnPause(boolean preserveOnPause) {
+ mPreserveEGLContextOnPause = preserveOnPause;
+ }
+
+ /**
+ * @return true if the EGL context will be preserved when paused
+ */
+ public boolean getPreserveEGLContextOnPause() {
+ return mPreserveEGLContextOnPause;
+ }
+
+ /**
+ * Set the renderer associated with this view. Also starts the thread that
+ * will call the renderer, which in turn causes the rendering to start.
+ *
This method should be called once and only once in the life-cycle of
+ * a GLSurfaceView.
+ *
The following GLSurfaceView methods can only be called before
+ * setRenderer is called:
+ *
+ * - {@link #setEGLConfigChooser(boolean)}
+ *
- {@link #setEGLConfigChooser(EGLConfigChooser)}
+ *
- {@link #setEGLConfigChooser(int, int, int, int, int, int)}
+ *
+ *
+ * The following GLSurfaceView methods can only be called after
+ * setRenderer is called:
+ *
+ * - {@link #getRenderMode()}
+ *
- {@link #onPause()}
+ *
- {@link #onResume()}
+ *
- {@link #queueEvent(Runnable)}
+ *
- {@link #requestRender()}
+ *
- {@link #setRenderMode(int)}
+ *
+ *
+ * @param renderer the renderer to use to perform OpenGL drawing.
+ */
+ public void setRenderer(Renderer renderer) {
+ checkRenderThreadState();
+ if (mEGLConfigChooser == null) {
+ mEGLConfigChooser = new SimpleEGLConfigChooser(true);
+ }
+ if (mEGLContextFactory == null) {
+ mEGLContextFactory = new DefaultContextFactory();
+ }
+ if (mEGLWindowSurfaceFactory == null) {
+ mEGLWindowSurfaceFactory = new DefaultWindowSurfaceFactory();
+ }
+ mRenderer = renderer;
+ mGLThread = new GLThread(mThisWeakRef);
+ mGLThread.start();
+ }
+
+ /**
+ * Install a custom EGLContextFactory.
+ * If this method is
+ * called, it must be called before {@link #setRenderer(Renderer)}
+ * is called.
+ *
+ * If this method is not called, then by default
+ * a context will be created with no shared context and
+ * with a null attribute list.
+ */
+ public void setEGLContextFactory(EGLContextFactory factory) {
+ checkRenderThreadState();
+ mEGLContextFactory = factory;
+ }
+
+ /**
+ * Install a custom EGLWindowSurfaceFactory.
+ *
If this method is
+ * called, it must be called before {@link #setRenderer(Renderer)}
+ * is called.
+ *
+ * If this method is not called, then by default
+ * a window surface will be created with a null attribute list.
+ */
+ public void setEGLWindowSurfaceFactory(EGLWindowSurfaceFactory factory) {
+ checkRenderThreadState();
+ mEGLWindowSurfaceFactory = factory;
+ }
+
+ /**
+ * Install a custom EGLConfigChooser.
+ *
If this method is
+ * called, it must be called before {@link #setRenderer(Renderer)}
+ * is called.
+ *
+ * If no setEGLConfigChooser method is called, then by default the
+ * view will choose an EGLConfig that is compatible with the current
+ * android.view.Surface, with a depth buffer depth of
+ * at least 16 bits.
+ * @param configChooser
+ */
+ public void setEGLConfigChooser(EGLConfigChooser configChooser) {
+ checkRenderThreadState();
+ mEGLConfigChooser = configChooser;
+ }
+
+ /**
+ * Install a config chooser which will choose a config
+ * as close to 16-bit RGB as possible, with or without an optional depth
+ * buffer as close to 16-bits as possible.
+ *
If this method is
+ * called, it must be called before {@link #setRenderer(Renderer)}
+ * is called.
+ *
+ * If no setEGLConfigChooser method is called, then by default the
+ * view will choose an RGB_888 surface with a depth buffer depth of
+ * at least 16 bits.
+ *
+ * @param needDepth
+ */
+ public void setEGLConfigChooser(boolean needDepth) {
+ setEGLConfigChooser(new SimpleEGLConfigChooser(needDepth));
+ }
+
+ /**
+ * Install a config chooser which will choose a config
+ * with at least the specified depthSize and stencilSize,
+ * and exactly the specified redSize, greenSize, blueSize and alphaSize.
+ *
If this method is
+ * called, it must be called before {@link #setRenderer(Renderer)}
+ * is called.
+ *
+ * If no setEGLConfigChooser method is called, then by default the
+ * view will choose an RGB_888 surface with a depth buffer depth of
+ * at least 16 bits.
+ *
+ */
+ public void setEGLConfigChooser(int redSize, int greenSize, int blueSize,
+ int alphaSize, int depthSize, int stencilSize) {
+ setEGLConfigChooser(new ComponentSizeChooser(redSize, greenSize,
+ blueSize, alphaSize, depthSize, stencilSize));
+ }
+
+ /**
+ * Inform the default EGLContextFactory and default EGLConfigChooser
+ * which EGLContext client version to pick.
+ *
Use this method to create an OpenGL ES 2.0-compatible context.
+ * Example:
+ *
+ * public MyView(Context context) {
+ * super(context);
+ * setEGLContextClientVersion(2); // Pick an OpenGL ES 2.0 context.
+ * setRenderer(new MyRenderer());
+ * }
+ *
+ * Note: Activities which require OpenGL ES 2.0 should indicate this by
+ * setting @lt;uses-feature android:glEsVersion="0x00020000" /> in the activity's
+ * AndroidManifest.xml file.
+ *
If this method is called, it must be called before {@link #setRenderer(Renderer)}
+ * is called.
+ *
This method only affects the behavior of the default EGLContexFactory and the
+ * default EGLConfigChooser. If
+ * {@link #setEGLContextFactory(EGLContextFactory)} has been called, then the supplied
+ * EGLContextFactory is responsible for creating an OpenGL ES 2.0-compatible context.
+ * If
+ * {@link #setEGLConfigChooser(EGLConfigChooser)} has been called, then the supplied
+ * EGLConfigChooser is responsible for choosing an OpenGL ES 2.0-compatible config.
+ * @param version The EGLContext client version to choose. Use 2 for OpenGL ES 2.0
+ */
+ public void setEGLContextClientVersion(int version) {
+ checkRenderThreadState();
+ mEGLContextClientVersion = version;
+ }
+
+ /**
+ * Set the rendering mode. When renderMode is
+ * RENDERMODE_CONTINUOUSLY, the renderer is called
+ * repeatedly to re-render the scene. When renderMode
+ * is RENDERMODE_WHEN_DIRTY, the renderer only rendered when the surface
+ * is created, or when {@link #requestRender} is called. Defaults to RENDERMODE_CONTINUOUSLY.
+ *
+ * Using RENDERMODE_WHEN_DIRTY can improve battery life and overall system performance
+ * by allowing the GPU and CPU to idle when the view does not need to be updated.
+ *
+ * This method can only be called after {@link #setRenderer(Renderer)}
+ *
+ * @param renderMode one of the RENDERMODE_X constants
+ * @see #RENDERMODE_CONTINUOUSLY
+ * @see #RENDERMODE_WHEN_DIRTY
+ */
+ public void setRenderMode(int renderMode) {
+ mGLThread.setRenderMode(renderMode);
+ }
+
+ /**
+ * Get the current rendering mode. May be called
+ * from any thread. Must not be called before a renderer has been set.
+ * @return the current rendering mode.
+ * @see #RENDERMODE_CONTINUOUSLY
+ * @see #RENDERMODE_WHEN_DIRTY
+ */
+ public int getRenderMode() {
+ return mGLThread.getRenderMode();
+ }
+
+ /**
+ * Request that the renderer render a frame.
+ * This method is typically used when the render mode has been set to
+ * {@link #RENDERMODE_WHEN_DIRTY}, so that frames are only rendered on demand.
+ * May be called
+ * from any thread. Must not be called before a renderer has been set.
+ */
+ public void requestRender() {
+ mGLThread.requestRender();
+ }
+
+ /**
+ * This method is part of the SurfaceHolder.Callback interface, and is
+ * not normally called or subclassed by clients of GLSurfaceView.
+ */
+ public void surfaceCreated(SurfaceHolder holder) {
+ mGLThread.surfaceCreated();
+ }
+
+ /**
+ * This method is part of the SurfaceHolder.Callback interface, and is
+ * not normally called or subclassed by clients of GLSurfaceView.
+ */
+ public void surfaceDestroyed(SurfaceHolder holder) {
+ // Surface will be destroyed when we return
+ mGLThread.surfaceDestroyed();
+ }
+
+ /**
+ * This method is part of the SurfaceHolder.Callback interface, and is
+ * not normally called or subclassed by clients of GLSurfaceView.
+ */
+ public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
+ mGLThread.onWindowResize(w, h);
+ }
+
+
+
+
+ /**
+ * This method is part of the SurfaceHolder.Callback2 interface, and is
+ * not normally called or subclassed by clients of GLSurfaceView.
+ */
+ @Override
+ public void surfaceRedrawNeededAsync(SurfaceHolder holder, Runnable finishDrawing) {
+ if (mGLThread != null) {
+ mGLThread.requestRenderAndNotify(finishDrawing);
+ }
+ }
+
+ /**
+ * This method is part of the SurfaceHolder.Callback2 interface, and is
+ * not normally called or subclassed by clients of GLSurfaceView.
+ */
+ @Deprecated
+ @Override
+ public void surfaceRedrawNeeded(SurfaceHolder holder) {
+ // Since we are part of the framework we know only surfaceRedrawNeededAsync
+ // will be called.
+ }
+
+
+ /**
+ * Pause the rendering thread, optionally tearing down the EGL context
+ * depending upon the value of {@link #setPreserveEGLContextOnPause(boolean)}.
+ *
+ * This method should be called when it is no longer desirable for the
+ * GLSurfaceView to continue rendering, such as in response to
+ * {@link android.app.Activity#onStop Activity.onStop}.
+ *
+ * Must not be called before a renderer has been set.
+ */
+ public void onPause() {
+ mGLThread.onPause();
+ }
+
+ /**
+ * Resumes the rendering thread, re-creating the OpenGL context if necessary. It
+ * is the counterpart to {@link #onPause()}.
+ *
+ * This method should typically be called in
+ * {@link android.app.Activity#onStart Activity.onStart}.
+ *
+ * Must not be called before a renderer has been set.
+ */
+ public void onResume() {
+ mGLThread.onResume();
+ }
+
+ /**
+ * Queue a runnable to be run on the GL rendering thread. This can be used
+ * to communicate with the Renderer on the rendering thread.
+ * Must not be called before a renderer has been set.
+ * @param r the runnable to be run on the GL rendering thread.
+ */
+ public void queueEvent(Runnable r) {
+ mGLThread.queueEvent(r);
+ }
+
+ /**
+ * This method is used as part of the View class and is not normally
+ * called or subclassed by clients of GLSurfaceView.
+ */
+ @Override
+ protected void onAttachedToWindow() {
+ super.onAttachedToWindow();
+ if (LOG_ATTACH_DETACH) {
+ Log.d(TAG, "onAttachedToWindow reattach =" + mDetached);
+ }
+ if (mDetached && (mRenderer != null)) {
+ int renderMode = RENDERMODE_CONTINUOUSLY;
+ if (mGLThread != null) {
+ renderMode = mGLThread.getRenderMode();
+ }
+ mGLThread = new GLThread(mThisWeakRef);
+ if (renderMode != RENDERMODE_CONTINUOUSLY) {
+ mGLThread.setRenderMode(renderMode);
+ }
+ mGLThread.start();
+ }
+ mDetached = false;
+ }
+
+ //新增方法，用于主线程等待销毁，不能再GL线程中调用
+ public void requestExitAndWait(){
+ if (mGLThread != null) {
+ if(mGLThread.getId() ==Thread.currentThread().getId()){
+ throw new RuntimeException("don't call this from GLThread thread or it is a guaranteed !! deadlock!");
+ }
+ mGLThread.requestExitAndWait();
+ }
+ }
+
+ @Override
+ protected void onDetachedFromWindow() {
+ if (LOG_ATTACH_DETACH) {
+ Log.d(TAG, "onDetachedFromWindow");
+ }
+ if (mGLThread != null) {
+ mGLThread.requestExitAndWait();
+ }
+ mDetached = true;
+ super.onDetachedFromWindow();
+ }
+
+ // ----------------------------------------------------------------------
+
+ /**
+ * An interface used to wrap a GL interface.
+ *
Typically
+ * used for implementing debugging and tracing on top of the default
+ * GL interface. You would typically use this by creating your own class
+ * that implemented all the GL methods by delegating to another GL instance.
+ * Then you could add your own behavior before or after calling the
+ * delegate. All the GLWrapper would do was instantiate and return the
+ * wrapper GL instance:
+ *
+ * class MyGLWrapper implements GLWrapper {
+ * GL wrap(GL gl) {
+ * return new MyGLImplementation(gl);
+ * }
+ * static class MyGLImplementation implements GL,GL10,GL11,... {
+ * ...
+ * }
+ * }
+ *
+ * @see #setGLWrapper(GLWrapper)
+ */
+ public interface GLWrapper {
+ /**
+ * Wraps a gl interface in another gl interface.
+ * @param gl a GL interface that is to be wrapped.
+ * @return either the input argument or another GL object that wraps the input argument.
+ */
+ GL wrap(GL gl);
+ }
+
+ /**
+ * A generic renderer interface.
+ *
+ * The renderer is responsible for making OpenGL calls to render a frame.
+ *
+ * GLSurfaceView clients typically create their own classes that implement
+ * this interface, and then call {@link AndroidGLSurfaceView#setRenderer} to
+ * register the renderer with the GLSurfaceView.
+ *
+ *
+ *
+ *
Developer Guides
+ *
For more information about how to use OpenGL, read the
+ * OpenGL developer guide.
+ *
Threading
+ * The renderer will be called on a separate thread, so that rendering
+ * performance is decoupled from the UI thread. Clients typically need to
+ * communicate with the renderer from the UI thread, because that's where
+ * input events are received. Clients can communicate using any of the
+ * standard Java techniques for cross-thread communication, or they can
+ * use the {@link AndroidGLSurfaceView#queueEvent(Runnable)} convenience method.
+ *
+ *
EGL Context Lost
+ * There are situations where the EGL rendering context will be lost. This
+ * typically happens when device wakes up after going to sleep. When
+ * the EGL context is lost, all OpenGL resources (such as textures) that are
+ * associated with that context will be automatically deleted. In order to
+ * keep rendering correctly, a renderer must recreate any lost resources
+ * that it still needs. The {@link #onSurfaceCreated(GL10, EGLConfig)} method
+ * is a convenient place to do this.
+ *
+ *
+ * @see #setRenderer(Renderer)
+ */
+ public interface Renderer {
+ /**
+ * Called when the surface is created or recreated.
+ *
+ * Called when the rendering thread
+ * starts and whenever the EGL context is lost. The EGL context will typically
+ * be lost when the Android device awakes after going to sleep.
+ *
+ * Since this method is called at the beginning of rendering, as well as
+ * every time the EGL context is lost, this method is a convenient place to put
+ * code to create resources that need to be created when the rendering
+ * starts, and that need to be recreated when the EGL context is lost.
+ * Textures are an example of a resource that you might want to create
+ * here.
+ *
+ * Note that when the EGL context is lost, all OpenGL resources associated
+ * with that context will be automatically deleted. You do not need to call
+ * the corresponding "glDelete" methods such as glDeleteTextures to
+ * manually delete these lost resources.
+ *
+ * @param gl the GL interface. Use instanceof to
+ * test if the interface supports GL11 or higher interfaces.
+ * @param config the EGLConfig of the created surface. Can be used
+ * to create matching pbuffers.
+ */
+ void onSurfaceCreated(GL10 gl, EGLConfig config);
+
+ /**
+ * Called when the surface changed size.
+ *
+ * Called after the surface is created and whenever
+ * the OpenGL ES surface size changes.
+ *
+ * Typically you will set your viewport here. If your camera
+ * is fixed then you could also set your projection matrix here:
+ *
+ * void onSurfaceChanged(GL10 gl, int width, int height) {
+ * gl.glViewport(0, 0, width, height);
+ * // for a fixed camera, set the projection too
+ * float ratio = (float) width / height;
+ * gl.glMatrixMode(GL10.GL_PROJECTION);
+ * gl.glLoadIdentity();
+ * gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);
+ * }
+ *
+ * @param gl the GL interface. Use instanceof to
+ * test if the interface supports GL11 or higher interfaces.
+ * @param width
+ * @param height
+ */
+ void onSurfaceChanged(GL10 gl, int width, int height);
+
+ /**
+ * Called to draw the current frame.
+ *
+ * This method is responsible for drawing the current frame.
+ *
+ * The implementation of this method typically looks like this:
+ *
+ * void onDrawFrame(GL10 gl) {
+ * gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
+ * //... other gl calls to render the scene ...
+ * }
+ *
+ * @param gl the GL interface. Use instanceof to
+ * test if the interface supports GL11 or higher interfaces.
+ */
+ void onDrawFrame(GL10 gl);
+
+
+ }
+
+ /**
+ * An interface for customizing the eglCreateContext and eglDestroyContext calls.
+ *
+ * This interface must be implemented by clients wishing to call
+ * {@link AndroidGLSurfaceView#setEGLContextFactory(EGLContextFactory)}
+ */
+ public interface EGLContextFactory {
+ EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig);
+ void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context);
+ }
+
+ private class DefaultContextFactory implements EGLContextFactory {
+ private int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
+
+ public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig config) {
+ int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, mEGLContextClientVersion,
+ EGL10.EGL_NONE };
+
+ return egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT,
+ mEGLContextClientVersion != 0 ? attrib_list : null);
+ }
+
+ public void destroyContext(EGL10 egl, EGLDisplay display,
+ EGLContext context) {
+ if (!egl.eglDestroyContext(display, context)) {
+ Log.e("DefaultContextFactory", "display:" + display + " context: " + context);
+ if (LOG_THREADS) {
+ Log.i("DefaultContextFactory", "tid=" + Thread.currentThread().getId());
+ }
+ EglHelper.throwEglException("eglDestroyContex", egl.eglGetError());
+ }
+ }
+ }
+
+ /**
+ * An interface for customizing the eglCreateWindowSurface and eglDestroySurface calls.
+ *
+ * This interface must be implemented by clients wishing to call
+ * {@link AndroidGLSurfaceView#setEGLWindowSurfaceFactory(EGLWindowSurfaceFactory)}
+ */
+ public interface EGLWindowSurfaceFactory {
+ /**
+ * @return null if the surface cannot be constructed.
+ */
+ EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display, EGLConfig config,
+ Object nativeWindow);
+ void destroySurface(EGL10 egl, EGLDisplay display, EGLSurface surface);
+ }
+
+ private static class DefaultWindowSurfaceFactory implements EGLWindowSurfaceFactory {
+
+ public EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display,
+ EGLConfig config, Object nativeWindow) {
+ EGLSurface result = null;
+ try {
+ result = egl.eglCreateWindowSurface(display, config, nativeWindow, null);
+ } catch (IllegalArgumentException e) {
+ // This exception indicates that the surface flinger surface
+ // is not valid. This can happen if the surface flinger surface has
+ // been torn down, but the application has not yet been
+ // notified via SurfaceHolder.Callback.surfaceDestroyed.
+ // In theory the application should be notified first,
+ // but in practice sometimes it is not. See b/4588890
+ Log.e(TAG, "eglCreateWindowSurface", e);
+ }
+ return result;
+ }
+
+ public void destroySurface(EGL10 egl, EGLDisplay display,
+ EGLSurface surface) {
+ egl.eglDestroySurface(display, surface);
+ }
+ }
+
+ /**
+ * An interface for choosing an EGLConfig configuration from a list of
+ * potential configurations.
+ *
+ * This interface must be implemented by clients wishing to call
+ * {@link AndroidGLSurfaceView#setEGLConfigChooser(EGLConfigChooser)}
+ */
+ public interface EGLConfigChooser {
+ /**
+ * Choose a configuration from the list. Implementors typically
+ * implement this method by calling
+ * {@link EGL10#eglChooseConfig} and iterating through the results. Please consult the
+ * EGL specification available from The Khronos Group to learn how to call eglChooseConfig.
+ * @param egl the EGL10 for the current display.
+ * @param display the current display.
+ * @return the chosen configuration.
+ */
+ EGLConfig chooseConfig(EGL10 egl, EGLDisplay display);
+ }
+
+ private abstract class BaseConfigChooser
+ implements EGLConfigChooser {
+ public BaseConfigChooser(int[] configSpec) {
+ mConfigSpec = filterConfigSpec(configSpec);
+ }
+
+ public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
+ int[] num_config = new int[1];
+ if (!egl.eglChooseConfig(display, mConfigSpec, null, 0,
+ num_config)) {
+ throw new IllegalArgumentException("eglChooseConfig failed");
+ }
+
+ int numConfigs = num_config[0];
+
+ if (numConfigs <= 0) {
+ throw new IllegalArgumentException(
+ "No configs match configSpec");
+ }
+
+ EGLConfig[] configs = new EGLConfig[numConfigs];
+ if (!egl.eglChooseConfig(display, mConfigSpec, configs, numConfigs,
+ num_config)) {
+ throw new IllegalArgumentException("eglChooseConfig#2 failed");
+ }
+ EGLConfig config = chooseConfig(egl, display, configs);
+ if (config == null) {
+ throw new IllegalArgumentException("No config chosen");
+ }
+ return config;
+ }
+
+ abstract EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
+ EGLConfig[] configs);
+
+ protected int[] mConfigSpec;
+
+ private int[] filterConfigSpec(int[] configSpec) {
+ if (mEGLContextClientVersion != 2 && mEGLContextClientVersion != 3) {
+ return configSpec;
+ }
+ /* We know none of the subclasses define EGL_RENDERABLE_TYPE.
+ * And we know the configSpec is well formed.
+ */
+ int len = configSpec.length;
+ int[] newConfigSpec = new int[len + 2];
+ System.arraycopy(configSpec, 0, newConfigSpec, 0, len-1);
+ newConfigSpec[len-1] = EGL10.EGL_RENDERABLE_TYPE;
+ if (mEGLContextClientVersion == 2) {
+ newConfigSpec[len] = EGL14.EGL_OPENGL_ES2_BIT; /* EGL_OPENGL_ES2_BIT */
+ } else {
+ newConfigSpec[len] = EGLExt.EGL_OPENGL_ES3_BIT_KHR; /* EGL_OPENGL_ES3_BIT_KHR */
+ }
+ newConfigSpec[len+1] = EGL10.EGL_NONE;
+ return newConfigSpec;
+ }
+ }
+
+ /**
+ * Choose a configuration with exactly the specified r,g,b,a sizes,
+ * and at least the specified depth and stencil sizes.
+ */
+ private class ComponentSizeChooser extends BaseConfigChooser {
+ public ComponentSizeChooser(int redSize, int greenSize, int blueSize,
+ int alphaSize, int depthSize, int stencilSize) {
+ super(new int[] {
+ EGL10.EGL_RED_SIZE, redSize,
+ EGL10.EGL_GREEN_SIZE, greenSize,
+ EGL10.EGL_BLUE_SIZE, blueSize,
+ EGL10.EGL_ALPHA_SIZE, alphaSize,
+ EGL10.EGL_DEPTH_SIZE, depthSize,
+ EGL10.EGL_STENCIL_SIZE, stencilSize,
+ EGL10.EGL_NONE});
+ mValue = new int[1];
+ mRedSize = redSize;
+ mGreenSize = greenSize;
+ mBlueSize = blueSize;
+ mAlphaSize = alphaSize;
+ mDepthSize = depthSize;
+ mStencilSize = stencilSize;
+ }
+
+ @Override
+ public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
+ EGLConfig[] configs) {
+ for (EGLConfig config : configs) {
+ int d = findConfigAttrib(egl, display, config,
+ EGL10.EGL_DEPTH_SIZE, 0);
+ int s = findConfigAttrib(egl, display, config,
+ EGL10.EGL_STENCIL_SIZE, 0);
+ if ((d >= mDepthSize) && (s >= mStencilSize)) {
+ int r = findConfigAttrib(egl, display, config,
+ EGL10.EGL_RED_SIZE, 0);
+ int g = findConfigAttrib(egl, display, config,
+ EGL10.EGL_GREEN_SIZE, 0);
+ int b = findConfigAttrib(egl, display, config,
+ EGL10.EGL_BLUE_SIZE, 0);
+ int a = findConfigAttrib(egl, display, config,
+ EGL10.EGL_ALPHA_SIZE, 0);
+ if ((r == mRedSize) && (g == mGreenSize)
+ && (b == mBlueSize) && (a == mAlphaSize)) {
+ return config;
+ }
+ }
+ }
+ return null;
+ }
+
+ private int findConfigAttrib(EGL10 egl, EGLDisplay display,
+ EGLConfig config, int attribute, int defaultValue) {
+
+ if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {
+ return mValue[0];
+ }
+ return defaultValue;
+ }
+
+ private int[] mValue;
+ // Subclasses can adjust these values:
+ protected int mRedSize;
+ protected int mGreenSize;
+ protected int mBlueSize;
+ protected int mAlphaSize;
+ protected int mDepthSize;
+ protected int mStencilSize;
+ }
+
+ /**
+ * This class will choose a RGB_888 surface with
+ * or without a depth buffer.
+ *
+ */
+ private class SimpleEGLConfigChooser extends ComponentSizeChooser {
+ public SimpleEGLConfigChooser(boolean withDepthBuffer) {
+ super(8, 8, 8, 0, withDepthBuffer ? 16 : 0, 0);
+ }
+ }
+
+ /**
+ * An EGL helper class.
+ */
+
+ private static class EglHelper {
+ public EglHelper(WeakReference glSurfaceViewWeakRef) {
+ mGLSurfaceViewWeakRef = glSurfaceViewWeakRef;
+ }
+
+ /**
+ * Initialize EGL for a given configuration spec.
+ * @param configSpec
+ */
+ public void start() {
+ if (LOG_EGL) {
+ Log.w("EglHelper", "start() tid=" + Thread.currentThread().getId());
+ }
+ /*
+ * Get an EGL instance
+ */
+ mEgl = (EGL10) EGLContext.getEGL();
+
+ /*
+ * Get to the default display.
+ */
+ mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
+
+ if (mEglDisplay == EGL10.EGL_NO_DISPLAY) {
+ throw new RuntimeException("eglGetDisplay failed");
+ }
+
+ /*
+ * We can now initialize EGL for that display
+ */
+ int[] version = new int[2];
+ if(!mEgl.eglInitialize(mEglDisplay, version)) {
+ throw new RuntimeException("eglInitialize failed");
+ }
+ AndroidGLSurfaceView view = mGLSurfaceViewWeakRef.get();
+ if (view == null) {
+ mEglConfig = null;
+ mEglContext = null;
+ } else {
+ mEglConfig = view.mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
+
+ /*
+ * Create an EGL context. We want to do this as rarely as we can, because an
+ * EGL context is a somewhat heavy object.
+ */
+ mEglContext = view.mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
+ }
+ if (mEglContext == null || mEglContext == EGL10.EGL_NO_CONTEXT) {
+ mEglContext = null;
+ throwEglException("createContext");
+ }
+ if (LOG_EGL) {
+ Log.w("EglHelper", "createContext " + mEglContext + " tid=" + Thread.currentThread().getId());
+ }
+
+ mEglSurface = null;
+ }
+
+ /**
+ * Create an egl surface for the current SurfaceHolder surface. If a surface
+ * already exists, destroy it before creating the new surface.
+ *
+ * @return true if the surface was created successfully.
+ */
+ public boolean createSurface() {
+ if (LOG_EGL) {
+ Log.e("EglHelper", "createSurface() tid=" + Thread.currentThread().getId());
+ }
+ /*
+ * Check preconditions.
+ */
+ if (mEgl == null) {
+ throw new RuntimeException("egl not initialized");
+ }
+ if (mEglDisplay == null) {
+ throw new RuntimeException("eglDisplay not initialized");
+ }
+ if (mEglConfig == null) {
+ throw new RuntimeException("mEglConfig not initialized");
+ }
+
+ /*
+ * The window size has changed, so we need to create a new
+ * surface.
+ */
+ destroySurfaceImp();
+
+ /*
+ * Create an EGL surface we can render into.
+ */
+ AndroidGLSurfaceView view = mGLSurfaceViewWeakRef.get();
+ if (view != null) {
+ mEglSurface = view.mEGLWindowSurfaceFactory.createWindowSurface(mEgl,
+ mEglDisplay, mEglConfig, view.getHolder());
+ } else {
+ mEglSurface = null;
+ }
+
+ if (mEglSurface == null || mEglSurface == EGL10.EGL_NO_SURFACE) {
+ int error = mEgl.eglGetError();
+ if (error == EGL10.EGL_BAD_NATIVE_WINDOW) {
+ Log.e("EglHelper", "createWindowSurface returned EGL_BAD_NATIVE_WINDOW.");
+ }
+ return false;
+ }
+
+ /*
+ * Before we can issue GL commands, we need to make sure
+ * the context is current and bound to a surface.
+ */
+ if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
+ /*
+ * Could not make the context current, probably because the underlying
+ * SurfaceView surface has been destroyed.
+ */
+ logEglErrorAsWarning("EGLHelper", "eglMakeCurrent", mEgl.eglGetError());
+ return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * Create a GL object for the current EGL context.
+ * @return
+ */
+ GL createGL() {
+
+ GL gl = mEglContext.getGL();
+ AndroidGLSurfaceView view = mGLSurfaceViewWeakRef.get();
+ if (view != null) {
+ if (view.mGLWrapper != null) {
+ gl = view.mGLWrapper.wrap(gl);
+ }
+
+ if ((view.mDebugFlags & (DEBUG_CHECK_GL_ERROR | DEBUG_LOG_GL_CALLS)) != 0) {
+ int configFlags = 0;
+ Writer log = null;
+ if ((view.mDebugFlags & DEBUG_CHECK_GL_ERROR) != 0) {
+ configFlags |= GLDebugHelper.CONFIG_CHECK_GL_ERROR;
+ }
+ if ((view.mDebugFlags & DEBUG_LOG_GL_CALLS) != 0) {
+ log = new LogWriter();
+ }
+ gl = GLDebugHelper.wrap(gl, configFlags, log);
+ }
+ }
+ return gl;
+ }
+
+ /**
+ * Display the current render surface.
+ * @return the EGL error code from eglSwapBuffers.
+ */
+ public int swap() {
+ if (! mEgl.eglSwapBuffers(mEglDisplay, mEglSurface)) {
+ return mEgl.eglGetError();
+ }
+ return EGL10.EGL_SUCCESS;
+ }
+
+ public void destroySurface() {
+ if (LOG_SURFACE) {
+ Log.e("GLThread", "destroySurface() tid=" + Thread.currentThread().getId());
+ }
+ destroySurfaceImp();
+ }
+
+ private void destroySurfaceImp() {
+ if (mEglSurface != null && mEglSurface != EGL10.EGL_NO_SURFACE) {
+ mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
+ EGL10.EGL_NO_SURFACE,
+ EGL10.EGL_NO_CONTEXT);
+ AndroidGLSurfaceView view = mGLSurfaceViewWeakRef.get();
+ if (view != null) {
+ view.mEGLWindowSurfaceFactory.destroySurface(mEgl, mEglDisplay, mEglSurface);
+ }
+ mEglSurface = null;
+ }
+ }
+
+ public void finish() {
+ if (LOG_EGL) {
+ Log.e("EglHelper", "finish() tid=" + Thread.currentThread().getId());
+ }
+ if (mEglContext != null) {
+ AndroidGLSurfaceView view = mGLSurfaceViewWeakRef.get();
+ if (view != null) {
+ view.mEGLContextFactory.destroyContext(mEgl, mEglDisplay, mEglContext);
+ }
+ mEglContext = null;
+ }
+ if (mEglDisplay != null) {
+ mEgl.eglTerminate(mEglDisplay);
+ mEglDisplay = null;
+ }
+ }
+
+ private void throwEglException(String function) {
+ throwEglException(function, mEgl.eglGetError());
+ }
+
+ public static void throwEglException(String function, int error) {
+ String message = formatEglError(function, error);
+ if (LOG_THREADS) {
+ Log.e("EglHelper", "throwEglException tid=" + Thread.currentThread().getId() + " "
+ + message);
+ }
+ throw new RuntimeException(message);
+ }
+
+ public static void logEglErrorAsWarning(String tag, String function, int error) {
+ Log.w(tag, formatEglError(function, error));
+ }
+
+ public static String formatEglError(String function, int error) {
+ return function + " failed: " + getErrorString(error);
+ }
+
+ private WeakReference mGLSurfaceViewWeakRef;
+ EGL10 mEgl;
+ EGLDisplay mEglDisplay;
+ EGLSurface mEglSurface;
+ EGLConfig mEglConfig;
+ EGLContext mEglContext;
+
+ }
+
+ /**
+ * A generic GL Thread. Takes care of initializing EGL and GL. Delegates
+ * to a Renderer instance to do the actual drawing. Can be configured to
+ * render continuously or on request.
+ *
+ * All potentially blocking synchronization is done through the
+ * sGLThreadManager object. This avoids multiple-lock ordering issues.
+ *
+ */
+ static class GLThread extends Thread {
+
+
+ GLThread(WeakReference glSurfaceViewWeakRef) {
+ super();
+ mWidth = 0;
+ mHeight = 0;
+ mRequestRender = true;
+ mRenderMode = RENDERMODE_CONTINUOUSLY;
+ mWantRenderNotification = false;
+ mGLSurfaceViewWeakRef = glSurfaceViewWeakRef;
+ }
+
+
+ @Override
+ public void run() {
+ setName("QuarkGLThread " + getId());
+ if (LOG_THREADS) {
+ Log.i("GLThread", "starting tid=" + getId());
+ }
+
+ try {
+ guardedRun();
+ } catch (InterruptedException e) {
+ // fall thru and exit normally
+ } finally {
+ sGLThreadManager.threadExiting(this);
+ }
+ }
+
+ /*
+ * This private method should only be called inside a
+ * synchronized(sGLThreadManager) block.
+ */
+ private void stopEglSurfaceLocked() {
+ if (mHaveEglSurface) {
+ mHaveEglSurface = false;
+ mEglHelper.destroySurface();
+ }
+ }
+
+ /*
+ * This private method should only be called inside a
+ * synchronized(sGLThreadManager) block.
+ */
+ private void stopEglContextLocked() {
+ if (mHaveEglContext) {
+ mEglHelper.finish();
+ mHaveEglContext = false;
+ sGLThreadManager.releaseEglContextLocked(this);
+ }
+ }
+ private void guardedRun() throws InterruptedException {
+ mEglHelper = new EglHelper(mGLSurfaceViewWeakRef);
+ mHaveEglContext = false;
+ mHaveEglSurface = false;
+ mWantRenderNotification = false;
+
+ try {
+ GL10 gl = null;
+ boolean createEglContext = false;
+ boolean createEglSurface = false;
+ boolean createGlInterface = false;
+ boolean lostEglContext = false;
+ boolean sizeChanged = false;
+ boolean wantRenderNotification = false;
+ boolean doRenderNotification = false;
+ boolean askedToReleaseEglContext = false;
+ int w = 0;
+ int h = 0;
+ Runnable event = null;
+ Runnable finishDrawingRunnable = null;
+
+ while (true) {
+ synchronized (sGLThreadManager) {
+ while (true) {
+ if (mShouldExit) {
+ return;
+ }
+
+ if (! mEventQueue.isEmpty()) {
+ event = mEventQueue.remove(0);
+ break;
+ }
+
+ // Update the pause state.
+ boolean pausing = false;
+ if (mPaused != mRequestPaused) {
+ pausing = mRequestPaused;
+ mPaused = mRequestPaused;
+ sGLThreadManager.notifyAll();
+ if (LOG_PAUSE_RESUME) {
+ Log.i("GLThread", "mPaused is now " + mPaused + " tid=" + getId());
+ }
+ }
+
+ // Have we lost the EGL context?
+ if (lostEglContext) {
+ stopEglSurfaceLocked();
+ stopEglContextLocked();
+ lostEglContext = false;
+ }
+
+ // When pausing, release the EGL surface:
+ if (pausing && mHaveEglSurface) {
+ if (LOG_SURFACE) {
+ Log.i("GLThread", "releasing EGL surface because paused tid=" + getId());
+ }
+ stopEglSurfaceLocked();
+ }
+
+ // When pausing, optionally release the EGL Context:
+ if (pausing && mHaveEglContext) {
+ AndroidGLSurfaceView view = mGLSurfaceViewWeakRef.get();
+ boolean preserveEglContextOnPause = view == null ?
+ false : view.mPreserveEGLContextOnPause;
+ if (!preserveEglContextOnPause) {
+ stopEglContextLocked();
+ if (LOG_SURFACE) {
+ Log.i("GLThread", "releasing EGL context because paused tid=" + getId());
+ }
+ }
+ }
+
+ // Have we lost the SurfaceView surface?
+ if ((! mHasSurface) && (! mWaitingForSurface)) {
+ if (LOG_SURFACE) {
+ Log.i("GLThread", "noticed surfaceView surface lost tid=" + getId());
+ }
+ if (mHaveEglSurface) {
+ stopEglSurfaceLocked();
+ }
+ mWaitingForSurface = true;
+ mSurfaceIsBad = false;
+ sGLThreadManager.notifyAll();
+ }
+
+ // Have we acquired the surface view surface?
+ if (mHasSurface && mWaitingForSurface) {
+ if (LOG_SURFACE) {
+ Log.i("GLThread", "noticed surfaceView surface acquired tid=" + getId());
+ }
+ mWaitingForSurface = false;
+ sGLThreadManager.notifyAll();
+ }
+
+ if (doRenderNotification) {
+ if (LOG_SURFACE) {
+ Log.i("GLThread", "sending render notification tid=" + getId());
+ }
+ mWantRenderNotification = false;
+ doRenderNotification = false;
+ mRenderComplete = true;
+ sGLThreadManager.notifyAll();
+ }
+
+ if (mFinishDrawingRunnable != null) {
+ finishDrawingRunnable = mFinishDrawingRunnable;
+ mFinishDrawingRunnable = null;
+ }
+
+ // Ready to draw?
+ if (readyToDraw()) {
+
+ // If we don't have an EGL context, try to acquire one.
+ if (! mHaveEglContext) {
+ if (askedToReleaseEglContext) {
+ askedToReleaseEglContext = false;
+ } else {
+ try {
+ mEglHelper.start();
+ } catch (RuntimeException t) {
+ sGLThreadManager.releaseEglContextLocked(this);
+ throw t;
+ }
+ mHaveEglContext = true;
+ createEglContext = true;
+
+ sGLThreadManager.notifyAll();
+ }
+ }
+
+ if (mHaveEglContext && !mHaveEglSurface) {
+ mHaveEglSurface = true;
+ createEglSurface = true;
+ createGlInterface = true;
+ sizeChanged = true;
+ }
+
+ if (mHaveEglSurface) {
+ if (mSizeChanged) {
+ sizeChanged = true;
+ w = mWidth;
+ h = mHeight;
+ mWantRenderNotification = true;
+ if (LOG_SURFACE) {
+ Log.i("GLThread",
+ "noticing that we want render notification tid="
+ + getId());
+ }
+
+ // Destroy and recreate the EGL surface.
+ createEglSurface = true;
+
+ mSizeChanged = false;
+ }
+ mRequestRender = false;
+ sGLThreadManager.notifyAll();
+ if (mWantRenderNotification) {
+ wantRenderNotification = true;
+ }
+ break;
+ }
+ } else {
+ if (finishDrawingRunnable != null) {
+ Log.w(TAG, "Warning, !readyToDraw() but waiting for " +
+ "draw finished! Early reporting draw finished.");
+ finishDrawingRunnable.run();
+ finishDrawingRunnable = null;
+ }
+ }
+ // By design, this is the only place in a GLThread thread where we wait().
+ if (LOG_THREADS) {
+ Log.i("GLThread", "waiting tid=" + getId()
+ + " mHaveEglContext: " + mHaveEglContext
+ + " mHaveEglSurface: " + mHaveEglSurface
+ + " mFinishedCreatingEglSurface: " + mFinishedCreatingEglSurface
+ + " mPaused: " + mPaused
+ + " mHasSurface: " + mHasSurface
+ + " mSurfaceIsBad: " + mSurfaceIsBad
+ + " mWaitingForSurface: " + mWaitingForSurface
+ + " mWidth: " + mWidth
+ + " mHeight: " + mHeight
+ + " mRequestRender: " + mRequestRender
+ + " mRenderMode: " + mRenderMode);
+ }
+ sGLThreadManager.wait();
+ }
+ } // end of synchronized(sGLThreadManager)
+
+ if (event != null) {
+ event.run();
+ event = null;
+ continue;
+ }
+
+ if (createEglSurface) {
+ if (LOG_SURFACE) {
+ Log.w("GLThread", "egl createSurface");
+ }
+ if (mEglHelper.createSurface()) {
+ Log.e("GLThread", "egl createSurface success");
+ synchronized(sGLThreadManager) {
+ mFinishedCreatingEglSurface = true;
+ sGLThreadManager.notifyAll();
+ }
+ } else {
+ Log.e("GLThread", "egl createSurface fail");
+ synchronized(sGLThreadManager) {
+ mFinishedCreatingEglSurface = true;
+ mSurfaceIsBad = true;
+ sGLThreadManager.notifyAll();
+ }
+ continue;
+ }
+ createEglSurface = false;
+ }
+
+ if (createGlInterface) {
+ gl = (GL10) mEglHelper.createGL();
+
+ createGlInterface = false;
+ }
+
+ if (createEglContext) {
+ if (LOG_RENDERER) {
+ Log.w("GLThread", "onSurfaceCreated");
+ }
+ AndroidGLSurfaceView view = mGLSurfaceViewWeakRef.get();
+ if (view != null) {
+ try {
+// Trace.traceBegin(Trace.TRACE_TAG_VIEW, "onSurfaceCreated");
+ view.mRenderer.onSurfaceCreated(gl, mEglHelper.mEglConfig);
+ } finally {
+// Trace.traceEnd(Trace.TRACE_TAG_VIEW);
+ }
+ }
+ createEglContext = false;
+ }
+
+ if (sizeChanged) {
+ if (LOG_RENDERER) {
+ Log.w("GLThread", "onSurfaceChanged(" + w + ", " + h + ")");
+ }
+ AndroidGLSurfaceView view = mGLSurfaceViewWeakRef.get();
+ if (view != null) {
+ try {
+// Trace.traceBegin(Trace.TRACE_TAG_VIEW, "onSurfaceChanged");
+ view.mRenderer.onSurfaceChanged(gl, w, h);
+ } finally {
+// Trace.traceEnd(Trace.TRACE_TAG_VIEW);
+ }
+ }
+ sizeChanged = false;
+ }
+
+ if (LOG_RENDERER_DRAW_FRAME) {
+ Log.w("GLThread", "onDrawFrame tid=" + getId());
+ }
+ {
+ AndroidGLSurfaceView view = mGLSurfaceViewWeakRef.get();
+ if (view != null) {
+ try {
+// Trace.traceBegin(Trace.TRACE_TAG_VIEW, "onDrawFrame");
+ view.mRenderer.onDrawFrame(gl);
+ if (finishDrawingRunnable != null) {
+ finishDrawingRunnable.run();
+ finishDrawingRunnable = null;
+ }
+ } finally {
+// Trace.traceEnd(Trace.TRACE_TAG_VIEW);
+ }
+ }
+ }
+ int swapError = mEglHelper.swap();
+ switch (swapError) {
+ case EGL10.EGL_SUCCESS:
+ break;
+ case EGL11.EGL_CONTEXT_LOST:
+ if (LOG_SURFACE) {
+ Log.i("GLThread", "egl context lost tid=" + getId());
+ }
+ lostEglContext = true;
+ break;
+ default:
+ // Other errors typically mean that the current surface is bad,
+ // probably because the SurfaceView surface has been destroyed,
+ // but we haven't been notified yet.
+ // Log the error to help developers understand why rendering stopped.
+ EglHelper.logEglErrorAsWarning("GLThread", "eglSwapBuffers", swapError);
+
+ synchronized(sGLThreadManager) {
+ mSurfaceIsBad = true;
+ sGLThreadManager.notifyAll();
+ }
+ break;
+ }
+
+ if (wantRenderNotification) {
+ doRenderNotification = true;
+ wantRenderNotification = false;
+ }
+ }
+
+ } finally {
+ /*
+ * clean-up everything...
+ */
+ synchronized (sGLThreadManager) {
+ stopEglSurfaceLocked();
+ stopEglContextLocked();
+ }
+ }
+ }
+
+ public boolean ableToDraw() {
+ return mHaveEglContext && mHaveEglSurface && readyToDraw();
+ }
+
+ private boolean readyToDraw() {
+ return (!mPaused) && mHasSurface && (!mSurfaceIsBad)
+ && (mWidth > 0) && (mHeight > 0)
+ && (mRequestRender || (mRenderMode == RENDERMODE_CONTINUOUSLY));
+ }
+
+ public void setRenderMode(int renderMode) {
+ if ( !((RENDERMODE_WHEN_DIRTY <= renderMode) && (renderMode <= RENDERMODE_CONTINUOUSLY)) ) {
+ throw new IllegalArgumentException("renderMode");
+ }
+ synchronized(sGLThreadManager) {
+ mRenderMode = renderMode;
+ sGLThreadManager.notifyAll();
+ }
+ }
+
+ public int getRenderMode() {
+ synchronized(sGLThreadManager) {
+ return mRenderMode;
+ }
+ }
+
+ public void requestRender() {
+ synchronized(sGLThreadManager) {
+ mRequestRender = true;
+ sGLThreadManager.notifyAll();
+ }
+ }
+
+ public void requestRenderAndNotify(Runnable finishDrawing) {
+ synchronized(sGLThreadManager) {
+ // If we are already on the GL thread, this means a client callback
+ // has caused reentrancy, for example via updating the SurfaceView parameters.
+ // We will return to the client rendering code, so here we don't need to
+ // do anything.
+ if (Thread.currentThread() == this) {
+ return;
+ }
+
+ mWantRenderNotification = true;
+ mRequestRender = true;
+ mRenderComplete = false;
+ mFinishDrawingRunnable = finishDrawing;
+
+ sGLThreadManager.notifyAll();
+ }
+ }
+
+ public void surfaceCreated() {
+ synchronized(sGLThreadManager) {
+ if (LOG_THREADS) {
+ Log.i("GLThread", "surfaceCreated tid=" + getId());
+ }
+ mHasSurface = true;
+ mFinishedCreatingEglSurface = false;
+ sGLThreadManager.notifyAll();
+ while (mWaitingForSurface
+ && !mFinishedCreatingEglSurface
+ && !mExited) {
+ try {
+ sGLThreadManager.wait();
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ }
+ }
+ }
+ }
+
+ public void surfaceDestroyed() {
+ synchronized(sGLThreadManager) {
+ if (LOG_THREADS) {
+ Log.i("GLThread", "surfaceDestroyed tid=" + getId());
+ }
+ mHasSurface = false;
+ sGLThreadManager.notifyAll();
+ while((!mWaitingForSurface) && (!mExited)) {
+ try {
+ sGLThreadManager.wait();
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ }
+ }
+ }
+ }
+
+ public void onPause() {
+ synchronized (sGLThreadManager) {
+ if (LOG_PAUSE_RESUME) {
+ Log.i("GLThread", "onPause tid=" + getId());
+ }
+ mRequestPaused = true;
+ sGLThreadManager.notifyAll();
+ while ((! mExited) && (! mPaused)) {
+ if (LOG_PAUSE_RESUME) {
+ Log.i("Main thread", "onPause waiting for mPaused.");
+ }
+ try {
+ sGLThreadManager.wait();
+ } catch (InterruptedException ex) {
+ Thread.currentThread().interrupt();
+ }
+ }
+ }
+ }
+
+ public void onResume() {
+ synchronized (sGLThreadManager) {
+ if (LOG_PAUSE_RESUME) {
+ Log.i("GLThread", "onResume tid=" + getId());
+ }
+ mRequestPaused = false;
+ mRequestRender = true;
+ mRenderComplete = false;
+ sGLThreadManager.notifyAll();
+ while ((! mExited) && mPaused && (!mRenderComplete)) {
+ if (LOG_PAUSE_RESUME) {
+ Log.i("Main thread", "onResume waiting for !mPaused.");
+ }
+ try {
+ sGLThreadManager.wait();
+ } catch (InterruptedException ex) {
+ Thread.currentThread().interrupt();
+ }
+ }
+ }
+ }
+
+ public void onWindowResize(int w, int h) {
+ synchronized (sGLThreadManager) {
+ mWidth = w;
+ mHeight = h;
+ mSizeChanged = true;
+ mRequestRender = true;
+ mRenderComplete = false;
+
+ // If we are already on the GL thread, this means a client callback
+ // has caused reentrancy, for example via updating the SurfaceView parameters.
+ // We need to process the size change eventually though and update our EGLSurface.
+ // So we set the parameters and return so they can be processed on our
+ // next iteration.
+ if (Thread.currentThread() == this) {
+ return;
+ }
+
+ sGLThreadManager.notifyAll();
+
+ // Wait for thread to react to resize and render a frame
+ while (! mExited && !mPaused && !mRenderComplete
+ && ableToDraw()) {
+ if (LOG_SURFACE) {
+ Log.i("Main thread", "onWindowResize waiting for render complete from tid=" + getId());
+ }
+ try {
+ sGLThreadManager.wait();
+ } catch (InterruptedException ex) {
+ Thread.currentThread().interrupt();
+ }
+ }
+ }
+ }
+
+ public void requestExitAndWait() {
+ // don't call this from GLThread thread or it is a guaranteed
+ // deadlock!
+ synchronized(sGLThreadManager) {
+ mShouldExit = true;
+ sGLThreadManager.notifyAll();
+ while (! mExited) {
+ try {
+ sGLThreadManager.wait();
+ } catch (InterruptedException ex) {
+ Thread.currentThread().interrupt();
+ }
+ }
+ }
+ }
+
+
+ /**
+ * Queue an "event" to be run on the GL rendering thread.
+ * @param r the runnable to be run on the GL rendering thread.
+ */
+ public void queueEvent(Runnable r) {
+ if (r == null) {
+ throw new IllegalArgumentException("r must not be null");
+ }
+ synchronized(sGLThreadManager) {
+ mEventQueue.add(r);
+ sGLThreadManager.notifyAll();
+ }
+ }
+
+ // Once the thread is started, all accesses to the following member
+ // variables are protected by the sGLThreadManager monitor
+ private boolean mShouldExit;
+ private boolean mExited;
+ private boolean mRequestPaused;
+ private boolean mPaused;
+ private boolean mHasSurface;
+ private boolean mSurfaceIsBad;
+ private boolean mWaitingForSurface;
+ private boolean mHaveEglContext;
+ private boolean mHaveEglSurface;
+ private boolean mFinishedCreatingEglSurface;
+ private boolean mShouldReleaseEglContext;
+ private int mWidth;
+ private int mHeight;
+ private int mRenderMode;
+ private boolean mRequestRender;
+ private boolean mWantRenderNotification;
+ private boolean mRenderComplete;
+ private ArrayList mEventQueue = new ArrayList();
+ private boolean mSizeChanged = true;
+ private Runnable mFinishDrawingRunnable = null;
+
+ // End of member variables protected by the sGLThreadManager monitor.
+
+ private EglHelper mEglHelper;
+
+ /**
+ * Set once at thread construction time, nulled out when the parent view is garbage
+ * called. This weak reference allows the GLSurfaceView to be garbage collected while
+ * the GLThread is still alive.
+ */
+ private WeakReference mGLSurfaceViewWeakRef;
+
+ }
+
+ static class LogWriter extends Writer {
+
+ @Override public void close() {
+ flushBuilder();
+ }
+
+ @Override public void flush() {
+ flushBuilder();
+ }
+
+ @Override public void write(char[] buf, int offset, int count) {
+ for(int i = 0; i < count; i++) {
+ char c = buf[offset + i];
+ if ( c == '\n') {
+ flushBuilder();
+ }
+ else {
+ mBuilder.append(c);
+ }
+ }
+ }
+
+ private void flushBuilder() {
+ if (mBuilder.length() > 0) {
+ Log.v("GLSurfaceView", mBuilder.toString());
+ mBuilder.delete(0, mBuilder.length());
+ }
+ }
+
+ private StringBuilder mBuilder = new StringBuilder();
+ }
+
+
+ private void checkRenderThreadState() {
+ if (mGLThread != null) {
+ throw new IllegalStateException(
+ "setRenderer has already been called for this instance.");
+ }
+ }
+
+ private static class GLThreadManager {
+ private static String TAG = "GLThreadManager";
+
+ public synchronized void threadExiting(GLThread thread) {
+ if (LOG_THREADS) {
+ Log.i("GLThread", "exiting tid=" + thread.getId());
+ }
+ thread.mExited = true;
+ notifyAll();
+ }
+
+ /*
+ * Releases the EGL context. Requires that we are already in the
+ * sGLThreadManager monitor when this is called.
+ */
+ public void releaseEglContextLocked(GLThread thread) {
+ notifyAll();
+ }
+ }
+
+ private static final GLThreadManager sGLThreadManager = new GLThreadManager();
+
+ private final WeakReference mThisWeakRef =
+ new WeakReference(this);
+ private GLThread mGLThread;
+ private Renderer mRenderer;
+ private boolean mDetached;
+ private EGLConfigChooser mEGLConfigChooser;
+ private EGLContextFactory mEGLContextFactory;
+ private EGLWindowSurfaceFactory mEGLWindowSurfaceFactory;
+ private GLWrapper mGLWrapper;
+ private int mDebugFlags;
+ private int mEGLContextClientVersion;
+ private boolean mPreserveEGLContextOnPause;
+
+ public static String getErrorString(int error) {
+ switch (error) {
+ case EGL14.EGL_SUCCESS:
+ return "EGL_SUCCESS";
+ case EGL14.EGL_NOT_INITIALIZED:
+ return "EGL_NOT_INITIALIZED";
+ case EGL14.EGL_BAD_ACCESS:
+ return "EGL_BAD_ACCESS";
+ case EGL14.EGL_BAD_ALLOC:
+ return "EGL_BAD_ALLOC";
+ case EGL14.EGL_BAD_ATTRIBUTE:
+ return "EGL_BAD_ATTRIBUTE";
+ case EGL14.EGL_BAD_CONFIG:
+ return "EGL_BAD_CONFIG";
+ case EGL14.EGL_BAD_CONTEXT:
+ return "EGL_BAD_CONTEXT";
+ case EGL14.EGL_BAD_CURRENT_SURFACE:
+ return "EGL_BAD_CURRENT_SURFACE";
+ case EGL14.EGL_BAD_DISPLAY:
+ return "EGL_BAD_DISPLAY";
+ case EGL14.EGL_BAD_MATCH:
+ return "EGL_BAD_MATCH";
+ case EGL14.EGL_BAD_NATIVE_PIXMAP:
+ return "EGL_BAD_NATIVE_PIXMAP";
+ case EGL14.EGL_BAD_NATIVE_WINDOW:
+ return "EGL_BAD_NATIVE_WINDOW";
+ case EGL14.EGL_BAD_PARAMETER:
+ return "EGL_BAD_PARAMETER";
+ case EGL14.EGL_BAD_SURFACE:
+ return "EGL_BAD_SURFACE";
+ case EGL11.EGL_CONTEXT_LOST:
+ return "EGL_CONTEXT_LOST";
+ default:
+ return getHex(error);
+ }
+ }
+
+
+ private static String getHex(int value) {
+ return "0x" + Integer.toHexString(value);
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/view/BasePreviewView.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/view/BasePreviewView.java
new file mode 100644
index 000000000..fc58e9782
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/view/BasePreviewView.java
@@ -0,0 +1,283 @@
+package com.quark.quamera.render.view;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.app.ActivityManager;
+import android.content.Context;
+import android.content.pm.ConfigurationInfo;
+import android.graphics.Color;
+import android.graphics.PixelFormat;
+import android.graphics.RectF;
+import android.os.Build;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.util.Rational;
+import android.util.Size;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+
+import com.quark.quamera.camera.preview.IPreviewView;
+import com.quark.quamera.camera.preview.ViewPort;
+import com.quark.quamera.camerax.controller.OnGestureDetectorListener;
+import com.quark.quamera.render.CameraVideoRenderExecutor;
+import com.quark.quamera.render.CameraVideoRenderPipe;
+import com.quark.quamera.render.detector.RenderExpansionManager;
+import com.quark.quamera.render.expansion.IRenderExpansion;
+import com.quark.quamera.render.photo.SnapShotCommand;
+import com.quark.quamera.util.CameraLogger;
+import com.quark.quamera.util.CameraShould;
+import com.quark.quamera.util.Should;
+
+import java.util.concurrent.Executor;
+
+import javax.microedition.khronos.egl.EGL10;
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.egl.EGLContext;
+import javax.microedition.khronos.egl.EGLDisplay;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/**
+ * Camera2和CameraX PreviewView的基类
+ *
+ * @author : yushan.lj@alibaba-inc.com
+ * @date : 2021/9/30
+ */
+public abstract class BasePreviewView extends FrameLayout implements IPreviewView {
+ private static final String TAG = "BasePreviewView";
+
+ private RenderExpansionManager mManager;
+ private final CameraVideoRenderPipe mRender;
+ private final AndroidGLSurfaceView mSurfaceView;
+ private static int GL_VERSION = -1;
+ private final Executor mExecutor;
+ private final View mMask;
+
+ public BasePreviewView(@NonNull Context context, @Nullable AttributeSet attrs) {
+ this(context, false);
+ }
+
+ /**
+ * @param ZOrderOverlay 解决低版本2个SurfaceView叠加显示问题
+ */
+ public BasePreviewView(@NonNull Context context, boolean ZOrderOverlay) {
+ super(context, null);
+ mSurfaceView = new AndroidGLSurfaceView(context);
+
+
+ if (Build.VERSION.SDK_INT <= 25) {
+ mSurfaceView.getHolder().setFormat(PixelFormat.OPAQUE);
+ mSurfaceView.setZOrderMediaOverlay(ZOrderOverlay);
+ }
+
+ if (!mSurfaceView.getPreserveEGLContextOnPause()) {
+ mSurfaceView.setPreserveEGLContextOnPause(true);
+ }
+
+ final int glVersion = getGLVersion(context);
+ Log.e(TAG, "GLVersion = " + glVersion);
+ mSurfaceView.setEGLContextClientVersion(glVersion);
+
+ if (glVersion == 2) {
+ CameraLogger.e(TAG, "not support gl 3.0");
+ }
+
+ mSurfaceView.setPreserveEGLContextOnPause(true);
+ mSurfaceView.setEGLConfigChooser(8, 8, 8, 8, 16, 0); // Alpha used for plane blending.
+ RenderExecutor executor = new RenderExecutor();
+ mManager = new RenderExpansionManager(context, executor);
+ mRender = new CameraVideoRenderPipe(context, mSurfaceView, mManager);
+ mSurfaceView.setEGLContextFactory(new AndroidGLSurfaceView.EGLContextFactory() {
+
+ @Override
+ public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {
+ int[] attributeList = {0x3098, glVersion, EGL10.EGL_NONE};
+ EGLContext eglContext = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attributeList);
+ Log.e(TAG, "create gl context");
+ return eglContext;
+ }
+
+
+ @Override
+ public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) {
+ Log.e(TAG, "begin destroy gl context");
+ mRender.onSurfaceDestroy();
+ if (!egl.eglDestroyContext(display, context)) {
+ Log.e("DefaultContextFactory", "display : " + display + " context : " + context);
+ }
+ Log.e(TAG, "finish destroy gl context");
+ }
+ });
+ mSurfaceView.setRenderer(mRender);
+ mSurfaceView.setRenderMode(AndroidGLSurfaceView.RENDERMODE_WHEN_DIRTY);
+ mExecutor = new CameraVideoRenderExecutor(mSurfaceView);
+ addView(mSurfaceView);
+
+ mMask = new View(context);
+ addView(mMask, new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+ }
+
+
+ private class RenderExecutor implements Executor {
+
+ @Override
+ public void execute(Runnable command) {
+ mRender.queueTask(() -> {
+ try {
+ command.run();
+ } catch (Throwable throwable) {
+ CameraShould.fail("", throwable);
+ }
+ });
+ }
+ }
+
+
+ public RenderExpansionManager getExpansionManager() {
+ return mManager;
+ }
+
+ public void pause() {
+ CameraLogger.i(TAG, "do pause");
+// mSurfaceView.onPause();
+ }
+
+ public void resume() {
+ CameraLogger.i(TAG, "do resume");
+// mSurfaceView.onResume();
+ }
+
+ @Override
+ public void snapshot(final SnapShotCommand snapShotCommand) {
+ CameraLogger.i(TAG, "VideoView.java = do mRender.snapshot");
+ mRender.snapshot(snapShotCommand);
+
+ mSurfaceView.requestRender();
+ }
+
+
+ public void setOnGestureDetectorListener(OnGestureDetectorListener listener) {
+
+ }
+
+ private ValueAnimator mTakePhotoAnimator;
+
+ @Override
+ public void doTakePhotoAnimation() {
+ post(this::doTakePhotoAnimationInner);
+ }
+
+ private void doTakePhotoAnimationInner() {
+ if (mTakePhotoAnimator != null) {
+ mTakePhotoAnimator.cancel();
+ }
+
+ mTakePhotoAnimator = ValueAnimator.ofFloat(0, 1, 0);
+ mTakePhotoAnimator.setDuration(200);
+ mTakePhotoAnimator.addListener(new AnimatorListenerAdapter() {
+ @Override
+ public void onAnimationStart(Animator animation) {
+ super.onAnimationStart(animation);
+ mMask.setVisibility(VISIBLE);
+ mMask.setBackgroundColor(Color.BLACK);
+ }
+
+ @Override
+ public void onAnimationCancel(Animator animation) {
+ super.onAnimationCancel(animation);
+ mMask.setVisibility(INVISIBLE);
+ }
+
+ @Override
+ public void onAnimationEnd(Animator animation) {
+ super.onAnimationEnd(animation);
+ mMask.setVisibility(INVISIBLE);
+ }
+ });
+ mTakePhotoAnimator.addUpdateListener(animation -> mMask.setAlpha((Float) animation.getAnimatedValue()));
+ mTakePhotoAnimator.start();
+ }
+
+
+ public void setScaleType(@ViewPort.ScaleType int scaleType) {
+ mRender.setCameraScaleType(scaleType);
+ }
+
+ @Override
+ public int getViewRotation() {
+ return 0;
+ }
+
+ @Override
+ public int getScaleType() {
+ return mRender.getCameraScaleType();
+ }
+
+ @Override
+ public Rational getAspectRatio() {
+ return mRender.getCameraShowRational();
+ }
+
+ @Override
+ public int getViewHeight() {
+ return getMeasuredWidth();
+ }
+
+ @Override
+ public int getViewWidth() {
+ return getMeasuredHeight();
+ }
+
+ @Override
+ public RectF getCameraShowRect() {
+ return mRender.getCameraShowRect();
+ }
+
+ private Size mCameraSurfaceSize;
+
+ @Override
+ public void updateCameraSurfaceSize(Size size) {
+ mCameraSurfaceSize = size;
+ }
+
+ @Override
+ public Size getCameraSurfaceSize() {
+ return mCameraSurfaceSize;
+ }
+
+ @NonNull
+ public CameraVideoRenderPipe getRender() {
+ return mRender;
+ }
+
+ public Executor getGLExecutor() {
+ return mExecutor;
+ }
+
+ public static synchronized int getGLVersion(Context context) {
+ if (GL_VERSION != -1) {
+ return GL_VERSION;
+ }
+ ConfigurationInfo cfgInfo;
+ try {
+ ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+ cfgInfo = am.getDeviceConfigurationInfo();
+ } catch (Exception e) {
+ cfgInfo = null;
+ }
+
+ //默认使用2作为GL版本
+ GL_VERSION = 2;
+ if (cfgInfo != null && cfgInfo.reqGlEsVersion >= 0x30000) {
+ GL_VERSION = 3;
+ } else {
+ Log.e(TAG, "not support gl version 3 (" + (cfgInfo != null ? cfgInfo.reqGlEsVersion : "unknown") + ")");
+ }
+
+ return GL_VERSION;
+ }
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/view/CameraVideoView.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/view/CameraVideoView.java
new file mode 100644
index 000000000..e09c8a7d6
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/view/CameraVideoView.java
@@ -0,0 +1,78 @@
+package com.quark.quamera.render.view;
+
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.os.Build;
+import android.util.AttributeSet;
+import android.view.Surface;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.quark.quamera.camera.preview.IPreviewSurfaceProvider;
+import com.quark.quamera.camera.preview.SurfaceTextureWrapper;
+import com.quark.quamera.render.DefaultCameraRender;
+import com.quark.quamera.util.CameraLogger;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.camera.core.FocusMeteringResult;
+import androidx.camera.core.impl.utils.futures.Futures;
+
+/**
+ * Camera2预览View
+ */
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class CameraVideoView extends BasePreviewView {
+
+ public CameraVideoView(@NonNull Context context, @Nullable AttributeSet attrs) {
+ this(context, false);
+ }
+
+ public CameraVideoView(Context context, boolean ZOrderOverlay) {
+ super(context, ZOrderOverlay);
+ }
+
+ @Override
+ public IPreviewSurfaceProvider getSurfaceProvider() {
+ return mPreviewSurfaceProvider;
+ }
+
+ @SuppressLint("RestrictedApi")
+ @Override
+ public ListenableFuture autoFocus(float x, float y, float size, long autoCancelTime) {
+ return Futures.immediateFailedFuture(new Throwable("not support"));
+ }
+
+ private DefaultCameraRender mDefaultCameraRender;
+ private final Object mSurfaceLock = new Object();
+
+ private final IPreviewSurfaceProvider mPreviewSurfaceProvider = new IPreviewSurfaceProvider() {
+ @Override
+ public Surface provide(@NonNull SurfaceRequest request) {
+ synchronized (mSurfaceLock) {
+ //释放当前surface texture
+ onUseComplete(null);
+
+ CameraLogger.i("CameraLifeManager", "onSurfaceRequested: previewWidth:" + request.width + " height:" + request.height);
+
+ SurfaceTextureWrapper surfaceTextureWrapper = new SurfaceTextureWrapper(request.width, request.height);
+ mDefaultCameraRender = new DefaultCameraRender(surfaceTextureWrapper, request.camera2Camera, request.repeatCaptureCallback);
+ getRender().setCameraRender(mDefaultCameraRender);
+
+ return surfaceTextureWrapper.getSurface();
+ }
+ }
+
+ @Override
+ public void onUseComplete(Surface surface) {
+ synchronized (mSurfaceLock) {
+ if (mDefaultCameraRender != null) {
+ CameraLogger.i("CameraVideoView", "onReleaseUseComplete");
+ mDefaultCameraRender.destroySurface();
+ mDefaultCameraRender = null;
+ }
+ }
+ }
+ };
+}
\ No newline at end of file
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/render/view/CameraXPreviewView.java b/mediapipe/render/android/camera/java/com/quark/quamera/render/view/CameraXPreviewView.java
new file mode 100644
index 000000000..9cd73ea96
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/render/view/CameraXPreviewView.java
@@ -0,0 +1,173 @@
+package com.quark.quamera.render.view;
+
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.os.Build;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.util.Size;
+import android.view.MotionEvent;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.quark.quamera.camera.preview.IPreviewSurfaceProvider;
+import com.quark.quamera.camera.preview.SurfaceTextureWrapper;
+import com.quark.quamera.camerax.CameraController;
+import com.quark.quamera.camerax.controller.CameraViewTouchManager;
+import com.quark.quamera.camerax.controller.ICameraViewTouchManager;
+import com.quark.quamera.camerax.controller.OnGestureDetectorListener;
+import com.quark.quamera.render.DefaultCameraRender;
+import com.quark.quamera.util.CameraLogger;
+
+import androidx.annotation.AnyThread;
+import androidx.annotation.GuardedBy;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.camera.camera2.internal.Camera2CameraCaptureResult;
+import androidx.camera.core.CameraSelector;
+import androidx.camera.core.FocusMeteringResult;
+import androidx.camera.core.Logger;
+import androidx.camera.core.Preview;
+import androidx.camera.core.SurfaceRequest;
+import androidx.camera.core.impl.CameraInternal;
+import androidx.core.content.ContextCompat;
+
+/**
+ * CameraX的预览View
+ */
+public class CameraXPreviewView extends BasePreviewView {
+ private static final String TAG = "CameraPreviewView";
+
+ private ICameraViewTouchManager mManager;
+ @GuardedBy("mSurfaceLock")
+ private DefaultCameraRender mDefaultCameraRender;
+
+
+ public CameraXPreviewView(@NonNull Context context, @Nullable AttributeSet attrs) {
+ this(context, false);
+ }
+
+ public CameraXPreviewView(Context context, boolean ZOderOverlay) {
+ super(context, ZOderOverlay);
+ mManager = new CameraViewTouchManager(this);
+ }
+
+ @Override
+ public void setOnGestureDetectorListener(OnGestureDetectorListener listener) {
+ mManager.setOnGestureDetectorListener(listener);
+ }
+
+ private final OnLayoutChangeListener mOnLayoutChangeListener =
+ (v, left, top, right, bottom, oldLeft, oldTop, oldRight, oldBottom) -> {
+ boolean isSizeChanged =
+ right - left != oldRight - oldLeft || bottom - top != oldBottom - oldTop;
+ if (isSizeChanged) {
+ mManager.onSizeChanged();
+ }
+ };
+
+ @Override
+ protected void onAttachedToWindow() {
+ super.onAttachedToWindow();
+ addOnLayoutChangeListener(mOnLayoutChangeListener);
+ mManager.onAttachedToWindow();
+ }
+
+ @Override
+ protected void onDetachedFromWindow() {
+ super.onDetachedFromWindow();
+ removeOnLayoutChangeListener(mOnLayoutChangeListener);
+ mManager.onDetachedFromWindow();
+ }
+
+ /**
+ * 用于相机缩放，轻点对焦的逻辑处理
+ */
+ public void setCameraController(CameraController cameraController) {
+ mManager.setCameraController(cameraController);
+ }
+
+ @SuppressLint("ClickableViewAccessibility")
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ return mManager.onTouchEvent(event) || super.onTouchEvent(event);
+ }
+
+ @Override
+ public boolean performClick() {
+ mManager.performClick();
+ return super.performClick();
+ }
+
+ @Override
+ public IPreviewSurfaceProvider getSurfaceProvider() {
+ return mPreviewSurfaceProvider;
+ }
+
+ @Override
+ public ListenableFuture autoFocus(float x, float y, float size, long autoCancelTime) {
+ return mManager.autoFocus(x, y, size, autoCancelTime);
+ }
+
+ final IPreviewSurfaceProvider mPreviewSurfaceProvider = new IPreviewSurfaceProvider() {
+ @Override
+ public Preview.SurfaceProvider providerSurface() {
+ return mSurfaceProvider;
+ }
+ };
+
+ final Preview.SurfaceProvider mSurfaceProvider = new Preview.SurfaceProvider() {
+
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ @SuppressLint({"RestrictedApi", "UnsafeOptInUsageError", "UnsafeExperimentalUsageError"})
+ @Override
+ @AnyThread
+ public void onSurfaceRequested(@NonNull SurfaceRequest request) {
+ post(() -> {
+ releaseSurface();
+
+ Log.i(TAG, "onSurfaceRequested provideSurface");
+ CameraInternal camera = request.getCamera();
+ request.setTransformationInfoListener(
+ ContextCompat.getMainExecutor(getContext()),
+ transformationInfo -> {
+ Logger.d(TAG, "Preview transformation info updated. " + transformationInfo);
+ camera.getCameraInfoInternal();
+
+ Integer lensFacing = camera.getCameraInfoInternal().getLensFacing();
+ boolean isFrontCamera = lensFacing != null &&
+ lensFacing == CameraSelector.LENS_FACING_FRONT;
+ mManager.setTransformationInfo(transformationInfo,
+ request.getResolution(), isFrontCamera);
+ });
+
+ Size size = request.getResolution();
+ CameraLogger.i("CameraLifeManager", "onSurfaceRequested: previewWidth:" + size.getWidth() + " height:" + size.getHeight());
+ //判断是否相同surface，不同重新创建 相同不处理
+ SurfaceTextureWrapper surfaceTextureWrapper = new SurfaceTextureWrapper(size.getWidth(), size.getHeight());
+ mDefaultCameraRender = new DefaultCameraRender(surfaceTextureWrapper, null, null);
+ getRender().setCameraRender(mDefaultCameraRender);
+ request.provideSurface(surfaceTextureWrapper.getSurface(),
+ getGLExecutor(), result1 -> {
+ // 判断是否相同surface
+ });
+
+ });
+ }
+ };
+
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ public void releaseSurface() {
+ if (mDefaultCameraRender != null) {
+ mDefaultCameraRender.destroySurface();
+ mDefaultCameraRender = null;
+ }
+ }
+
+ public void cacheCaptureResult(Camera2CameraCaptureResult captureResult) {
+ if (mDefaultCameraRender != null) {
+ mDefaultCameraRender.cacheCameraXCaptureResult(captureResult);
+ }
+ }
+}
\ No newline at end of file
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/ArrayUtil.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/ArrayUtil.java
new file mode 100644
index 000000000..48719aad3
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/ArrayUtil.java
@@ -0,0 +1,144 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.quark.quamera.util;
+
+
+import androidx.annotation.RestrictTo;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.List;
+
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+public class ArrayUtil {
+ public static final int INDEX_NOT_FOUND = -1;
+
+ public static int indexOf(final T[] array, final T objectToFind) {
+ return indexOf(array, objectToFind, 0);
+ }
+
+ /**
+ * 如果array是有序的，请使用{@link java.util.Arrays#binarySearch(int[], int)}
+ */
+ public static int search(int[] array, int value) {
+ if (array == null) {
+ return -1;
+ }
+ for (int i = 0; i < array.length; i++) {
+ if (array[i] == value) {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ public static int indexOf(final T[] array, final T objectToFind, int startIndex) {
+ if (array == null) {
+ return INDEX_NOT_FOUND;
+ }
+ if (startIndex < 0) {
+ startIndex = 0;
+ }
+ if (objectToFind == null) {
+ for (int i = startIndex; i < array.length; i++) {
+ if (array[i] == null) {
+ return i;
+ }
+ }
+ } else {
+ for (int i = startIndex; i < array.length; i++) {
+ if (objectToFind.equals(array[i])) {
+ return i;
+ }
+ }
+ }
+ return INDEX_NOT_FOUND;
+ }
+
+ public static boolean contains(final T[] array, final T objectToFind) {
+ return indexOf(array, objectToFind) != INDEX_NOT_FOUND;
+ }
+
+ public static boolean isEmpty(final byte[] array) {
+ return getLength(array) == 0;
+ }
+
+ public static boolean isEmpty(final long[] array) {
+ return getLength(array) == 0;
+ }
+
+ public static boolean isEmpty(final int[] array) {
+ return getLength(array) == 0;
+ }
+
+ public static boolean isEmpty(final T[] array) {
+ return getLength(array) == 0;
+ }
+
+ private static int getLength(final Object array) {
+ if (array == null) {
+ return 0;
+ }
+ return Array.getLength(array);
+ }
+
+ public static byte[] add(final byte[] array, final byte element) {
+ final byte[] newArray = (byte[]) copyArrayGrow1(array, Byte.TYPE);
+ newArray[newArray.length - 1] = element;
+ return newArray;
+ }
+
+ private static Object copyArrayGrow1(final Object array, final Class newArrayComponentType) {
+ if (array != null) {
+ final int arrayLength = Array.getLength(array);
+ final Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
+ System.arraycopy(array, 0, newArray, 0, arrayLength);
+ return newArray;
+ }
+ return Array.newInstance(newArrayComponentType, 1);
+ }
+
+ public static byte[] addAll(final byte[] array1, final byte... array2) {
+ if (array1 == null) {
+ return clone(array2);
+ } else if (array2 == null) {
+ return clone(array1);
+ }
+ final byte[] joinedArray = new byte[array1.length + array2.length];
+ System.arraycopy(array1, 0, joinedArray, 0, array1.length);
+ System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
+ return joinedArray;
+ }
+
+ public static byte[] clone(final byte[] array) {
+ if (array == null) {
+ return null;
+ }
+ return array.clone();
+ }
+
+
+ public static T[] findAllIf(T[] container, CollectionUtil.Predicate pred) {
+ List list = new ArrayList();
+ for (T item : container) {
+ if (pred.evaluate(item)) {
+ list.add(item);
+ }
+ }
+ return (T[]) list.toArray();
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/Camera2CaptureResultManager.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/Camera2CaptureResultManager.java
new file mode 100644
index 000000000..71d762fe9
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/Camera2CaptureResultManager.java
@@ -0,0 +1,164 @@
+package com.quark.quamera.util;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/5/26
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.hardware.camera2.CaptureResult;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.annotation.RequiresApi;
+
+import com.quark.quamera.camera.session.CameraCaptureResult;
+import com.quark.quamera.render.DefaultCameraRender;
+
+import java.lang.ref.WeakReference;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * 立即释放CaptureResult中CameraMetadataNative持有的Native内存
+ *
+ * CameraMetadataNative 默认情况下是执行GC的时候，会释放C++内存，但是会不及时，因为Native Heap上涨不会导致GC触发，但是会导致OOM
+ *
+ * 目前的方式通过反射实现，存在一定的兼容性风险；对于而已。GC+内存检测兼容性好点，但是性能可能没有那么好
+ */
+public class Camera2CaptureResultManager {
+
+ public final static String TAG = "Camera2MemManager";
+ private int mMaxCache = 40;
+ private boolean mEnable = true;
+
+ public Camera2CaptureResultManager() {
+ this(40);
+ }
+
+ public Camera2CaptureResultManager(int maxCache) {
+ this.mMaxCache = maxCache;
+ mEnable = CameraInit.getConfig().enableHighMemoryGC();
+ }
+
+
+ private final Queue> mCacheCacheResult = new LinkedList<>();
+
+ public void cacheCaptureResult(CameraCaptureResult captureResult) {
+ if (!mEnable) {
+ return;
+ }
+
+ if (captureResult == null) {
+ return;
+ }
+ synchronized (mCacheCacheResult) {
+ if (mCacheCacheResult.size() > mMaxCache) {
+ mCacheCacheResult.remove();
+ }
+ if (CameraInit.getConfig().isDebuggable()) {
+ Log.d(TAG,
+ "CameraCaptureCallback.onCaptureCompleted collect -- " + captureResult.getTimestamp());
+ }
+ mCacheCacheResult.add(new WeakReference<>(captureResult));
+ }
+ }
+
+ /**
+ * 消费并且删除 相对于 surfaceTimeStamp 过期的Result
+ * 基于假设 SurfaceTexture的队列timestamp一定是递增的
+ */
+ public CameraCaptureResult consumeMatchCaptureResult(long surfaceTimeStamp) {
+ if (!mEnable) {
+ return null;
+ }
+ synchronized (mCacheCacheResult) {
+ Iterator> it = mCacheCacheResult.iterator();
+ while (it.hasNext()) {
+ CameraCaptureResult result = it.next().get();
+ if (result == null) {
+ it.remove();
+ continue;
+ }
+ if (result.getTimestamp() < surfaceTimeStamp) {
+ //移除掉时间比较小的
+ it.remove();
+ }
+ if (result.getTimestamp() == surfaceTimeStamp) {
+ it.remove();
+ return result;
+ }
+ }
+ return null;
+ }
+ }
+
+ public void clear() {
+ synchronized (mCacheCacheResult) {
+ mCacheCacheResult.clear();
+ }
+ }
+
+
+ private static Field sCameraMetaDataNativeField;
+ private static Method sCameraMetaDataCloseMethod;
+ private static Class sClass;
+
+ /**
+ * 立即释放CaptureResult中CameraMetadataNative持有的Native内存
+ *
+ * CameraMetadataNative 默认情况下是执行GC的时候，会释放C++内存，但是会不及时，因为Native Heap上涨不会导致GC触发，但是会导致OOM
+ */
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ public boolean releaseCaptureResultNow(CameraCaptureResult captureResult) {
+ if (!mEnable) {
+ return false;
+ }
+
+ if (captureResult == null || captureResult.getCaptureResult() == null) {
+ return false;
+ }
+ try {
+ if (sCameraMetaDataNativeField == null) {
+ sCameraMetaDataNativeField = CaptureResult.class.getDeclaredField("mResults");
+ sCameraMetaDataNativeField.setAccessible(true);
+ }
+
+ if (sClass == null) {
+ sClass = Class.forName("android.hardware.camera2.impl.CameraMetadataNative");
+ }
+
+ if (sCameraMetaDataCloseMethod == null) {
+ sCameraMetaDataCloseMethod = CameraReflection.findMethod(sClass, "finalize");
+ sCameraMetaDataCloseMethod.setAccessible(true);
+ }
+
+ } catch (NoSuchFieldException e) {
+ e.printStackTrace();
+ } catch (ClassNotFoundException e) {
+ e.printStackTrace();
+ } catch (NoSuchMethodException e) {
+ e.printStackTrace();
+ }
+
+ if (sCameraMetaDataCloseMethod == null || sCameraMetaDataNativeField == null) {
+ return false;
+ }
+
+ try {
+ long timeState = captureResult.getTimestamp();
+ sCameraMetaDataCloseMethod.invoke(sCameraMetaDataNativeField.get(captureResult.getCaptureResult()));
+ Log.d(DefaultCameraRender.TAG, "CaptureFrameHelper.release --- " + timeState);
+ return true;
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ return false;
+ }
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/CameraInit.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/CameraInit.java
new file mode 100644
index 000000000..25b1909b2
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/CameraInit.java
@@ -0,0 +1,52 @@
+package com.quark.quamera.util;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/4/15
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import androidx.annotation.NonNull;
+
+public class CameraInit {
+
+
+ private static CameraEvnConfig sConfig = defaultConfig();
+
+ private static CameraEvnConfig defaultConfig() {
+ return new CameraEvnConfig()
+ .setDebuggable(false);
+ }
+
+ public static class CameraEvnConfig {
+ private boolean mDebuggable = false;
+ private boolean mEnableHighMemoryGC = true;
+
+ public CameraEvnConfig setDebuggable(boolean debuggable) {
+ mDebuggable = debuggable;
+ return CameraEvnConfig.this;
+ }
+
+ public boolean isDebuggable() {
+ return mDebuggable;
+ }
+
+ public boolean enableHighMemoryGC() {
+ return mEnableHighMemoryGC;
+ }
+
+ public CameraEvnConfig setEnableHighMemoryGC(boolean enableHighMemoryGC) {
+ mEnableHighMemoryGC = enableHighMemoryGC;
+ return CameraEvnConfig.this;
+ }
+ }
+
+ public static void init(@NonNull CameraEvnConfig config) {
+ sConfig = config;
+ }
+
+ public static CameraEvnConfig getConfig() {
+ return sConfig;
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/CameraLogger.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/CameraLogger.java
new file mode 100644
index 000000000..59244a744
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/CameraLogger.java
@@ -0,0 +1,129 @@
+package com.quark.quamera.util;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-19
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.hardware.camera2.CameraDevice;
+import android.os.Build;
+
+import androidx.annotation.RequiresApi;
+
+
+public class CameraLogger {
+
+ public interface ILogger {
+ void onError(String tag, String message);
+
+ void onInfo(String tag, String message);
+
+ void onTestLongLog(String tag, String message);
+
+ void uploadError(String tag, String message);
+ }
+
+ private static ILogger sLogger;
+
+ public static void setLoggerImp(ILogger logger) {
+ sLogger = logger;
+ }
+
+
+
+ public static void e(String tag, String message, Object... other) {
+ try {
+
+ if (sLogger == null) {
+ return;
+ }
+
+ if (other != null) {
+ message = String.format(message, other);
+ }
+
+ sLogger.onError(tag, message);
+ } catch (Exception e) {
+ }
+ }
+
+
+ public static void i(String tag, String message, Object... other) {
+ try {
+
+ if (sLogger == null) {
+ return;
+ }
+
+ if (other != null) {
+ message = String.format(message, other);
+ }
+
+ sLogger.onInfo(tag, message);
+
+ } catch (Exception e) {
+ CameraShould.fail(message, e);
+ }
+ }
+
+ /**
+ * 通用debug开启
+ */
+ @TestOnly
+ public static void testLongLog(String tag, String message, Object... other) {
+ try {
+ if (sLogger == null) {
+ return;
+ }
+ message = String.format(message, other);
+
+ sLogger.onTestLongLog(tag, message);
+
+ } catch (Exception e) {
+ CameraShould.fail(message, e);
+ }
+ }
+
+ public static void uploadError(String tag, String message) {
+ try {
+ if (sLogger == null) {
+ return;
+ }
+
+ sLogger.uploadError(tag, message);
+
+ } catch (Exception e) {
+ CameraShould.fail(message, e);
+ }
+ }
+
+
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ @SuppressWarnings("WeakerAccess") /* synthetic accessor */
+ public static String getCameraErrorMessage(int errorCode) {
+ switch (errorCode) {
+// case Camera2CameraImpl.ERROR_NONE:
+// return "ERROR_NONE";
+ case CameraDevice.StateCallback.ERROR_CAMERA_DEVICE:
+ return "ERROR_CAMERA_DEVICE";
+ case CameraDevice.StateCallback.ERROR_CAMERA_DISABLED:
+ return "ERROR_CAMERA_DISABLED";
+ case CameraDevice.StateCallback.ERROR_CAMERA_IN_USE:
+ return "ERROR_CAMERA_IN_USE";
+ case CameraDevice.StateCallback.ERROR_CAMERA_SERVICE:
+ return "ERROR_CAMERA_SERVICE";
+ case CameraDevice.StateCallback.ERROR_MAX_CAMERAS_IN_USE:
+ return "ERROR_MAX_CAMERAS_IN_USE";
+ case ERROR_TRY_REOPEN_ERROR:
+ return "ERROR_TRY_REOPEN_ERROR_OVER_MAX_TIMES";
+ default: // fall out
+ }
+ return "UNKNOWN ERROR ( " + errorCode + " ) ";
+ }
+
+ public static final int ERROR_TRY_REOPEN_ERROR = -10;
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/CameraReflection.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/CameraReflection.java
new file mode 100644
index 000000000..a390cd1bd
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/CameraReflection.java
@@ -0,0 +1,205 @@
+package com.quark.quamera.util;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+
+/**
+ * Source code from Tinker
+ */
+public final class CameraReflection {
+
+ private CameraReflection() {
+
+ }
+
+ /**
+ * Locates a given field anywhere in the class inheritance hierarchy.
+ *
+ * @param instance an object to search the field from.
+ * @param name field name
+ * @return a field object
+ * @throws NoSuchFieldException if the field cannot be located
+ */
+ static Field findField(Object instance, String name) throws NoSuchFieldException {
+ for (Class clazz = instance.getClass(); clazz != null; clazz = clazz.getSuperclass()) {
+ try {
+ Field field = clazz.getDeclaredField(name);
+ if (!field.isAccessible()) {
+ field.setAccessible(true);
+ }
+ return field;
+ } catch (NoSuchFieldException e) {
+ // ignore and search next
+ }
+ }
+
+ throw new NoSuchFieldException("Field " + name + " not found in " + instance.getClass());
+ }
+
+ static Field findField(Class originClazz, String name) throws NoSuchFieldException {
+ for (Class clazz = originClazz; clazz != null; clazz = clazz.getSuperclass()) {
+ try {
+ Field field = clazz.getDeclaredField(name);
+
+ if (!field.isAccessible()) {
+ field.setAccessible(true);
+ }
+
+ return field;
+ } catch (NoSuchFieldException e) {
+ // ignore and search next
+ }
+ }
+
+ throw new NoSuchFieldException("Field " + name + " not found in " + originClazz);
+ }
+
+
+ /**
+ * Locates a given method anywhere in the class inheritance hierarchy.
+ *
+ * @param clazz a class to search the method from.
+ * @param name method name
+ * @param parameterTypes method parameter types
+ * @return a method object
+ * @throws NoSuchMethodException if the method cannot be located
+ */
+ public static Method findMethod(Class clazz, String name, Class... parameterTypes)
+ throws NoSuchMethodException {
+ for (; clazz != null; clazz = clazz.getSuperclass()) {
+ try {
+ Method method = clazz.getDeclaredMethod(name, parameterTypes);
+
+ if (!method.isAccessible()) {
+ method.setAccessible(true);
+ }
+
+ return method;
+ } catch (NoSuchMethodException e) {
+ // ignore and search next
+ }
+ }
+
+ throw new NoSuchMethodException("Method "
+ + name
+ + " with parameters "
+ + Arrays.asList(parameterTypes)
+ + " not found in " + clazz);
+ }
+
+ /**
+ * Locates a given constructor anywhere in the class inheritance hierarchy.
+ *
+ * @param instance an object to search the constructor from.
+ * @param parameterTypes constructor parameter types
+ * @return a constructor object
+ * @throws NoSuchMethodException if the constructor cannot be located
+ */
+ static Constructor findConstructor(Object instance, Class... parameterTypes)
+ throws NoSuchMethodException {
+ for (Class clazz = instance.getClass(); clazz != null; clazz = clazz.getSuperclass()) {
+ try {
+ Constructor ctor = clazz.getDeclaredConstructor(parameterTypes);
+
+ if (!ctor.isAccessible()) {
+ ctor.setAccessible(true);
+ }
+
+ return ctor;
+ } catch (NoSuchMethodException e) {
+ // ignore and search next
+ }
+ }
+
+ throw new NoSuchMethodException("Constructor"
+ + " with parameters "
+ + Arrays.asList(parameterTypes)
+ + " not found in " + instance.getClass());
+ }
+
+ /**
+ * Locates a given constructor anywhere in the class inheritance hierarchy.
+ *
+ * @param clazz a class to search the method from.
+ * @param parameterTypes constructor parameter types
+ * @return a constructor object
+ * @throws NoSuchMethodException if the constructor cannot be located
+ */
+ static Constructor findConstructor(Class clazz, Class... parameterTypes)
+ throws NoSuchMethodException {
+ for (; clazz != null; clazz = clazz.getSuperclass()) {
+ try {
+ Constructor ctor = clazz.getDeclaredConstructor(parameterTypes);
+
+ if (!ctor.isAccessible()) {
+ ctor.setAccessible(true);
+ }
+
+ return ctor;
+ } catch (NoSuchMethodException e) {
+ // ignore and search next
+ }
+ }
+
+ throw new NoSuchMethodException("Constructor"
+ + " with parameters "
+ + Arrays.asList(parameterTypes)
+ + " not found in " + clazz);
+ }
+
+ /**
+ * Replace the value of a field containing a non-null array, by a new array containing the
+ * elements of the original array plus the elements of extraElements.
+ *
+ * @param instance the instance whose field is to be modified.
+ * @param fieldName the field to modify.
+ * @param extraElements elements to append at the end of the array.
+ */
+ static void expandFieldArray(Object instance, String fieldName, Object[] extraElements)
+ throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
+ Field jlrField = findField(instance, fieldName);
+
+ Object[] original = (Object[]) jlrField.get(instance);
+ Object[] combined = (Object[]) Array.newInstance(original.getClass().getComponentType(), original.length + extraElements.length);
+
+ // NOTE: changed to copy extraElements first, for patch load first
+
+ System.arraycopy(extraElements, 0, combined, 0, extraElements.length);
+ System.arraycopy(original, 0, combined, extraElements.length, original.length);
+
+ jlrField.set(instance, combined);
+ }
+
+ /**
+ * Replace the value of a field containing a non-null array, by a new array containing the
+ * elements of the original array plus the elements of extraElements.
+ *
+ * @param instance the instance whose field is to be modified.
+ * @param fieldName the field to modify.
+ */
+ static void reduceFieldArray(Object instance, String fieldName, int reduceSize)
+ throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
+ if (reduceSize <= 0) {
+ return;
+ }
+
+ Field jlrField = findField(instance, fieldName);
+
+ Object[] original = (Object[]) jlrField.get(instance);
+ int finalLength = original.length - reduceSize;
+
+ if (finalLength <= 0) {
+ return;
+ }
+
+ Object[] combined = (Object[]) Array.newInstance(original.getClass().getComponentType(), finalLength);
+
+ System.arraycopy(original, reduceSize, combined, 0, finalLength);
+
+ jlrField.set(instance, combined);
+ }
+}
+
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/CameraShould.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/CameraShould.java
new file mode 100644
index 000000000..d15f19c1b
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/CameraShould.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2004 - 2016 UCWeb Inc. All Rights Reserved.
+ * Creation : 2016/5/5
+ * Author : lzm89888@alibaba-inc.com
+ */
+
+package com.quark.quamera.util;
+
+import android.text.TextUtils;
+import android.util.Log;
+
+import java.util.Collection;
+
+
+/**
+ * 一个简单的断言工具
+ */
+public class CameraShould {
+ private static final String TAG = "Should";
+
+
+ private static boolean sShouldThrowError = true;
+
+ /**
+ * 设置当Should的条件不满足时是否抛出AssertionError, 如果设置为否，则当Should的条件不满足时，仅
+ * 输出error log, 不会抛出AssertionError
+ * 一般情况下，开发和内测版本设置抛出异常，正式和灰度版本为了产品的最大可用性，仅输出error log.
+ *
+ * @param enable 是否需要抛出AssertionError
+ */
+ public static void setThrowAssertionError(boolean enable) {
+ sShouldThrowError = enable;
+ }
+
+ public static void notNull(Object obj) {
+ notNull(obj, "notNull assert fail");
+ }
+
+ public static void notNull(Object obj, String msg) {
+ notNullIf(obj, true, msg);
+ }
+
+ /**
+ * 在ifCondition为true的情况下，obj不应为null
+ */
+ public static void notNullIf(Object obj, boolean ifCondition) {
+ notNullIf(obj, ifCondition, "notNullIf assert fail");
+ }
+
+ public static void notNullIf(Object obj, boolean ifCondition, String msg) {
+ if (ifCondition && obj == null) {
+ throwAssertionError(msg);
+ }
+ }
+
+ private static void throwAssertionError(String msg) {
+ throwAssertionError(msg, null);
+ }
+
+ private static void throwAssertionError(String msg, Throwable t) {
+ if (sShouldThrowError) {
+ if (t != null) {
+ Log.e("throwAssertionError", msg);
+ throw new AssertionError(t);
+ } else {
+ throw new AssertionError(msg);
+ }
+ } else {
+ CameraLogger.uploadError(msg, Log.getStackTraceString(t));
+ }
+ }
+
+ public static void beNullIf(Object obj, boolean ifCondition) {
+ beNullIf(obj, ifCondition, "beNullIf assert fail");
+ }
+
+ public static void beNullIf(Object obj, boolean ifCondition, String msg) {
+ if (ifCondition && obj != null) {
+ throwAssertionError(msg);
+ }
+ }
+
+ public static void notEmpty(CharSequence str) {
+ notEmptyIf(str, true, "notEmpty assert fail");
+ }
+
+ public static void notEmptyIf(CharSequence str, boolean ifCondition) {
+ notEmptyIf(str, ifCondition, "notEmptyIf assert fail");
+ }
+
+ public static void notEmptyIf(CharSequence str, boolean ifCondition, String msg) {
+ if (ifCondition && TextUtils.isEmpty(str)) {
+ throwAssertionError(msg);
+ }
+ }
+
+ public static void notEmpty(Collection c) {
+ notEmptyIf(c, true, "notEmpty assert fail");
+ }
+
+ public static void notEmptyIf(Collection c, boolean ifCondition, String msg) {
+ if (ifCondition && (c == null || c.isEmpty())) {
+ throwAssertionError(msg);
+ }
+ }
+
+ public static void beTrue(boolean b) {
+ beTrueIf(b, true);
+ }
+
+ public static void beTrue(boolean b, String msg) {
+ beTrueIf(b, true, msg);
+ }
+
+ /**
+ * 在ifCondition为true的情况下，断言b为true
+ */
+ public static void beTrueIf(boolean b, boolean ifCondition) {
+ beTrueIf(b, ifCondition, "beTrueIf assert fail");
+ }
+
+ public static void beTrueIf(boolean b, boolean ifCondition, String msg) {
+ if (ifCondition && !b) {
+ throwAssertionError(msg);
+ }
+ }
+
+ public static void beFalse(boolean b, String msg) {
+ beFalseIf(b, true, msg);
+ }
+
+ public static void beFalse(boolean b) {
+ beFalseIf(b, true);
+ }
+
+ public static void beFalseIf(boolean b, boolean ifCondition) {
+ beFalseIf(b, ifCondition, "beFalseIf assert fail");
+ }
+
+ public static void beFalseIf(boolean b, boolean ifCondition, String msg) {
+ if (ifCondition && b) {
+ throwAssertionError(msg);
+ }
+ }
+
+ public static void fail() {
+ fail("assert fail");
+ }
+
+ public static void fail(String msg) {
+ throwAssertionError(msg);
+ }
+
+ public static void fail(String msg, Throwable t) {
+ throwAssertionError(msg, t);
+ }
+
+ public static void beEqual(int origin, int expect) {
+ if (origin != expect) {
+ throwAssertionError("" + origin + " not equal to " + expect);
+ }
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/CollectionUtil.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/CollectionUtil.java
new file mode 100644
index 000000000..083729a8d
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/CollectionUtil.java
@@ -0,0 +1,63 @@
+package com.quark.quamera.util;
+
+import androidx.annotation.RestrictTo;
+
+import java.util.Collection;
+
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+public class CollectionUtil {
+
+ /**
+ * An easy way to test a Collection is empty or not.
+ *
+ * @param container
+ * @return {@code true} if the container is empty
+ */
+ public static boolean isEmpty(Collection container) {
+ return container == null || container.isEmpty();
+ }
+
+
+ public interface Predicate {
+ boolean evaluate(T object);
+ }
+
+
+ /**
+ * @param inputCollection
+ * @param predicate
+ * @param outputCollection 当inputCollection和predicate都不为null时, 不能传null
+ * @param
+ * @param
+ * @return
+ */
+ public static > R select(Collection inputCollection, Predicate predicate, R outputCollection) {
+ if (inputCollection != null && predicate != null) {
+ for (final T item : inputCollection) {
+ if (predicate.evaluate(item)) {
+ outputCollection.add(item);
+ }
+ }
+ }
+ return outputCollection;
+ }
+
+ /*package*/
+ static Collection cast(Iterable iterable) {
+ return (Collection) iterable;
+ }
+
+ /**
+ * Applies {@code action} to each element in {@code cur}
+ */
+ public static void forEach(Iterable cur, Consumer action) {
+ if (cur == null || action == null) return;
+ for (final T item : cur) {
+ action.accept(item);
+ }
+ }
+
+ public interface Consumer {
+ void accept(T t);
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/GlCommonUtil.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/GlCommonUtil.java
new file mode 100644
index 000000000..0cdd935c4
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/GlCommonUtil.java
@@ -0,0 +1,196 @@
+//
+// Source code recreated from a .class file by IntelliJ IDEA
+// (powered by Fernflower decompiler)
+//
+
+package com.quark.quamera.util;
+
+import android.annotation.TargetApi;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.opengl.GLES20;
+import android.opengl.GLUtils;
+
+
+import java.nio.Buffer;
+
+@TargetApi(18)
+public class GlCommonUtil {
+ public static final String TAG = "GlCommonUtil";
+ public static final int NO_TEXTURE = -1;
+
+ public GlCommonUtil() {
+ }
+
+ public static int createProgram(String vertexSource, String fragmentSource) {
+ int vs = loadShader(35633, vertexSource);
+ int fs = loadShader(35632, fragmentSource);
+ int program = GLES20.glCreateProgram();
+ GLES20.glAttachShader(program, vs);
+ GLES20.glAttachShader(program, fs);
+ GLES20.glLinkProgram(program);
+ int[] linkStatus = new int[1];
+ GLES20.glGetProgramiv(program, 35714, linkStatus, 0);
+ if (linkStatus[0] != 1) {
+ CameraLogger.e("GlCommonUtil", "Could not link program:");
+ CameraLogger.e("GlCommonUtil", GLES20.glGetProgramInfoLog(program));
+ GLES20.glDeleteProgram(program);
+ program = 0;
+ }
+
+ return program;
+ }
+
+ public static int loadShader(int shaderType, String source) {
+ int shader = GLES20.glCreateShader(shaderType);
+ GLES20.glShaderSource(shader, source);
+ GLES20.glCompileShader(shader);
+ int[] compiled = new int[1];
+ GLES20.glGetShaderiv(shader, 35713, compiled, 0);
+ if (compiled[0] == 0) {
+ CameraLogger.e("GlCommonUtil", "Could not compile shader(TYPE=" + shaderType + "):");
+ CameraLogger.e("GlCommonUtil", GLES20.glGetShaderInfoLog(shader));
+ GLES20.glDeleteShader(shader);
+ shader = 0;
+ }
+
+ return shader;
+ }
+
+ public static void checkGlError(String op) {
+ int glCode = GLES20.glGetError();
+ if (glCode != 0) {
+ CameraShould.fail(String.format("GLUtils::CheckGLError GL Operation %s() glError (0x%x)\n ", op, glCode));
+ }
+ }
+
+ public static void checkEglError(String op) {
+ }
+
+ public static void deleteGLTexture(int iTextureID) {
+ GLES20.glActiveTexture(33984);
+ int[] aTextures = new int[]{iTextureID};
+ GLES20.glDeleteTextures(1, aTextures, 0);
+ }
+
+ public static void deleteGLTexture(int[] textures) {
+ GLES20.glDeleteTextures(textures.length, textures, 0);
+ }
+
+ public static void createFramebuffers(int[] framebuffers, int[] framebufferTextures, int[] renderBuffers, int width, int height) {
+ if (null != framebuffers && null != framebufferTextures && width > 0 && height > 0 && framebuffers.length == framebufferTextures.length) {
+ for (int i = 0; i < framebuffers.length; ++i) {
+ GLES20.glGenFramebuffers(1, framebuffers, i);
+ GLES20.glGenTextures(1, framebufferTextures, i);
+ GLES20.glGenRenderbuffers(1, renderBuffers, i);
+ GLES20.glBindTexture(3553, framebufferTextures[i]);
+ GLES20.glTexImage2D(3553, 0, 6408, width, height, 0, 6408, 5121, (Buffer) null);
+ GLES20.glTexParameterf(3553, 10240, 9729.0F);
+ GLES20.glTexParameterf(3553, 10241, 9729.0F);
+ GLES20.glTexParameterf(3553, 10242, 33071.0F);
+ GLES20.glTexParameterf(3553, 10243, 33071.0F);
+ GLES20.glBindFramebuffer(36160, framebuffers[i]);
+ GLES20.glFramebufferTexture2D(36160, 36064, 3553, framebufferTextures[i], 0);
+ GLES20.glBindRenderbuffer(36161, renderBuffers[i]);
+ GLES20.glRenderbufferStorage(36161, 33189, width, height);
+ GLES20.glFramebufferRenderbuffer(36160, 36096, 36161, renderBuffers[i]);
+ GLES20.glBindTexture(3553, 0);
+ GLES20.glBindFramebuffer(36160, 0);
+ GLES20.glBindRenderbuffer(36161, 0);
+ }
+
+ } else {
+ CameraLogger.e("GlCommonUtil", "createFramebuffers param is error!");
+ }
+ }
+
+ public static void destroyFramebuffers(int[] framebuffers, int[] framebufferTextures, int[] renderBuffers) {
+ if (framebuffers != null) {
+ GLES20.glDeleteFramebuffers(framebuffers.length, framebuffers, 0);
+ Object framebuffers1 = null;
+ }
+
+ if (framebufferTextures != null) {
+ GLES20.glDeleteTextures(framebufferTextures.length, framebufferTextures, 0);
+ Object framebufferTextures1 = null;
+ }
+
+ if (renderBuffers != null) {
+ GLES20.glDeleteRenderbuffers(renderBuffers.length, renderBuffers, 0);
+ Object renderBuffers1 = null;
+ }
+
+ }
+
+ public static int createTexture(int width, int height) {
+ if (width <= 0 | height <= 0) {
+ CameraLogger.e("GlCommonUtil", "createTexture param is error!");
+ return -1;
+ } else {
+ int[] textures = new int[1];
+ GLES20.glGenTextures(1, textures, 0);
+ GLES20.glBindTexture(3553, textures[0]);
+ GLES20.glTexParameterf(3553, 10240, 9729.0F);
+ GLES20.glTexParameterf(3553, 10241, 9729.0F);
+ GLES20.glTexParameterf(3553, 10242, 33071.0F);
+ GLES20.glTexParameterf(3553, 10243, 33071.0F);
+ GLES20.glTexImage2D(3553, 0, 6408, width, height, 0, 6408, 5121, (Buffer) null);
+ return textures[0];
+ }
+ }
+
+ public static void createTextures(int[] textures, int width, int height) {
+ if (null != textures && textures.length >= 1 && width >= 0 && height >= 0) {
+ for (int i = 0; i < textures.length; ++i) {
+ textures[i] = createTexture(width, height);
+ }
+
+ } else {
+ CameraLogger.e("GlCommonUtil", "createTextures param is error!");
+ }
+ }
+
+ public static int loadTexture(Bitmap img, int usedTexId, boolean recycle) {
+ int[] textures = new int[1];
+ if (usedTexId == -1) {
+ GLES20.glGenTextures(1, textures, 0);
+ GLES20.glBindTexture(3553, textures[0]);
+ GLES20.glTexParameterf(3553, 10240, 9729.0F);
+ GLES20.glTexParameterf(3553, 10241, 9729.0F);
+ GLES20.glTexParameterf(3553, 10242, 33071.0F);
+ GLES20.glTexParameterf(3553, 10243, 33071.0F);
+ GLUtils.texImage2D(3553, 0, img, 0);
+ } else {
+ GLES20.glBindTexture(3553, usedTexId);
+ GLUtils.texSubImage2D(3553, 0, 0, 0, img);
+ textures[0] = usedTexId;
+ }
+
+ if (recycle) {
+ img.recycle();
+ }
+
+ return textures[0];
+ }
+
+ public static int loadTexture(String imgPath, int usedTexId) {
+ Bitmap img = BitmapFactory.decodeFile(imgPath);
+ int[] textures = new int[1];
+ if (usedTexId == -1) {
+ GLES20.glGenTextures(1, textures, 0);
+ GLES20.glBindTexture(3553, textures[0]);
+ GLES20.glTexParameterf(3553, 10240, 9729.0F);
+ GLES20.glTexParameterf(3553, 10241, 9729.0F);
+ GLES20.glTexParameterf(3553, 10242, 33071.0F);
+ GLES20.glTexParameterf(3553, 10243, 33071.0F);
+ GLUtils.texImage2D(3553, 0, img, 0);
+ } else {
+ GLES20.glBindTexture(3553, usedTexId);
+ GLUtils.texSubImage2D(3553, 0, 0, 0, img);
+ textures[0] = usedTexId;
+ }
+
+ img.recycle();
+ return textures[0];
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/IOUtils.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/IOUtils.java
new file mode 100644
index 000000000..a5970b204
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/IOUtils.java
@@ -0,0 +1,26 @@
+package com.quark.quamera.util;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/2/20
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import androidx.annotation.RestrictTo;
+
+import java.io.Closeable;
+
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+public class IOUtils {
+ public static void safeClose(Closeable closeable) {
+ if (closeable == null) {
+ return;
+ }
+ try {
+ closeable.close();
+ } catch (Exception ignore) {
+ CameraShould.fail();
+ }
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/ImageUtils.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/ImageUtils.java
new file mode 100644
index 000000000..9bedc5b7c
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/ImageUtils.java
@@ -0,0 +1,254 @@
+package com.quark.quamera.util;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 2021/7/13
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.graphics.ImageFormat;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.media.Image;
+import android.opengl.Matrix;
+import android.os.Build;
+import android.util.Log;
+import android.util.Rational;
+import android.util.Size;
+
+import com.quark.quamera.camera.preview.ViewPort;
+
+import androidx.annotation.IntRange;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.exifinterface.media.ExifInterface;
+
+public class ImageUtils {
+
+ /**
+ * Converts a {@link Size} to an float array of vertexes.
+ */
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ @NonNull
+ public static float[] sizeToVertexes(@NonNull Size size) {
+ return new float[]{0, 0, size.getWidth(), 0, size.getWidth(), size.getHeight(), 0,
+ size.getHeight()};
+ }
+
+ /**
+ * Returns the min value.
+ */
+ public static float min(float value1, float value2, float value3, float value4) {
+ return Math.min(Math.min(value1, value2), Math.min(value3, value4));
+ }
+
+
+ /**
+ * Checks whether the exif orientation value should be used for the final output image.
+ *
+ * On some devices, the orientation value in the embedded exif of the captured images may
+ * be 0 but the image buffer data actually is not rotated to upright orientation by HAL. For
+ * these devices, the exif orientation value should not be used for the final output image.
+ *
+ * @param image The captured image object.
+ */
+ @RequiresApi(api = Build.VERSION_CODES.KITKAT)
+ public static boolean shouldUseExifOrientation(@NonNull Image image) {
+ if (image.getFormat() != ImageFormat.JPEG) {
+ return false;
+ }
+
+ if (isHuaweiMate20Lite() || isHonor9X()) {
+ return false;
+ }
+
+ return true;
+ }
+
+ private static boolean isHuaweiMate20Lite() {
+ return "HUAWEI".equalsIgnoreCase(Build.BRAND) && "SNE-LX1".equalsIgnoreCase(Build.MODEL);
+ }
+
+ private static boolean isHonor9X() {
+ return "HONOR".equalsIgnoreCase(Build.BRAND) && "STK-LX1".equalsIgnoreCase(
+ Build.MODEL);
+ }
+
+
+ /**
+ * @return The degree of rotation (eg. 0, 90, 180, 270).
+ */
+ public static int getRotation(int exifRotation) {
+ switch (exifRotation) {
+ case ExifInterface.ORIENTATION_FLIP_HORIZONTAL:
+ return 0;
+ case ExifInterface.ORIENTATION_ROTATE_180:
+ return 180;
+ case ExifInterface.ORIENTATION_FLIP_VERTICAL:
+ return 180;
+ case ExifInterface.ORIENTATION_TRANSPOSE:
+ return 270;
+ case ExifInterface.ORIENTATION_ROTATE_90:
+ return 90;
+ case ExifInterface.ORIENTATION_TRANSVERSE:
+ return 90;
+ case ExifInterface.ORIENTATION_ROTATE_270:
+ return 270;
+ case ExifInterface.ORIENTATION_NORMAL:
+ // Fall-through
+ case ExifInterface.ORIENTATION_UNDEFINED:
+ // Fall-through
+ default:
+ return 0;
+ }
+ }
+
+ /**
+ * Rotates aspect ratio based on rotation degrees.
+ */
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ @NonNull
+ public static Rational getRotatedAspectRatio(
+ @IntRange(from = 0, to = 359) int rotationDegrees,
+ @NonNull Rational aspectRatio) {
+ if (rotationDegrees == 90 || rotationDegrees == 270) {
+ return inverseRational(aspectRatio);
+ }
+
+ return new Rational(aspectRatio.getNumerator(), aspectRatio.getDenominator());
+ }
+
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ private static Rational inverseRational(Rational rational) {
+ if (rational == null) {
+ return rational;
+ }
+ return new Rational(
+ /*numerator=*/ rational.getDenominator(),
+ /*denominator=*/ rational.getNumerator());
+ }
+
+ /**
+ * 根据scale类型，对顶点坐标矩阵进行转换
+ *
+ * @param scaleType 目前仅仅支持 {@link ViewPort#FILL_CENTER}
+ */
+ public static boolean getScaleVertexMatrix(@ViewPort.ScaleType int scaleType, float[] outMatrix,
+ int in_width, int in_height, int out_width, int out_height) {
+ if (in_width <= 0
+ || in_height <= 0
+ || out_width <= 0
+ || out_height <= 0) {
+ return false;
+ }
+
+ switch (scaleType) {
+ case ViewPort.FILL_CENTER: {
+ Matrix.setIdentityM(outMatrix, 0);
+ float input_radio = (float) in_height / (float) in_width;
+ float out_radio = (float) out_height / (float) out_width;
+
+ //注意顶点坐标空间为 -1,1,所以只要直接缩放就行
+ if (input_radio > out_radio) {
+ Matrix.scaleM(outMatrix, 0, 1f, (float) input_radio / (float) out_radio, 1.0F);
+ } else {
+ Matrix.scaleM(outMatrix, 0, (float) out_radio / (float) input_radio, 1f, 1.0F);
+ }
+ return true;
+ }
+ case ViewPort.CENTER_INSIDE: {
+ Matrix.setIdentityM(outMatrix, 0);
+ float input_radio = (float) in_height / (float) in_width;
+ float out_radio = (float) out_height / (float) out_width;
+
+ Log.i("A_TAG", "in_height: " + in_height + " in_width: " + in_width + " " +
+ " input_radio: " + input_radio + " out_height:" + out_height + " out_width：" + out_width + " out_radio： " + out_radio);
+ if (input_radio > out_radio) {
+ Matrix.scaleM(outMatrix, 0, out_radio / input_radio, 1f, 1.0F);
+ } else {
+ Matrix.scaleM(outMatrix, 0, 1f, input_radio / out_radio, 1.0F);
+ }
+ break;
+ }
+ default: {
+ CameraShould.fail("not support now");
+ }
+ }
+ return false;
+ }
+
+ /**
+ * 注意顶点坐标空间为 -1,1
+ *
+ * @param heightPercentage 需要裁剪成的Y的高度，0.7表示裁剪掉底部0.3区域
+ */
+ public static boolean getClipVertexMatrix(float[] outMatrix, float[] marginPercentage) {
+ Matrix.setIdentityM(outMatrix, 0);
+ Matrix.translateM(outMatrix, 0, 0, marginPercentage[3] - marginPercentage[1], 0.0F);
+ Matrix.scaleM(outMatrix, 0, 1f, 1 - marginPercentage[1] - marginPercentage[3], 1.0F);
+ return true;
+ }
+
+ @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+ public static Rect convert2JpegRect(Rect jpegRect, int jpegRotation, Rect desRect, Size dstSize) {
+ RectF jpegShowClip = new RectF(desRect);
+ android.graphics.Matrix matrix = new android.graphics.Matrix();
+ matrix.postScale(1f / dstSize.getWidth(), 1f / dstSize.getHeight());
+ if (jpegRotation != 0) {
+ matrix.postRotate(-jpegRotation, 0.5f, 0.5f);
+ }
+
+ matrix.postScale(jpegRect.width(), jpegRect.height());
+ matrix.postTranslate(jpegRect.left, jpegRect.top);
+
+ matrix.mapRect(jpegShowClip);
+
+ Rect resultJpegShowClip = new Rect();
+ jpegShowClip.round(resultJpegShowClip);
+
+ return resultJpegShowClip;
+ }
+
+
+ private final static RectF sPreviewScaleRect = new RectF();
+ private final static RectF sCameraSurfaceRect = new RectF();
+ private final static RectF sCameraShowRect = new RectF();
+ private final static android.graphics.Matrix sSurface2PreviewScaleRectTransform = new android.graphics.Matrix();
+
+ public synchronized static void calculateCameraShowRect(RectF result,
+ @ViewPort.ScaleType int scaleType,
+ float[] marginPercentage,
+ int[] cameraSurfaceSize, int[] windowSize) {
+
+
+ // sPreviewScaleRect.set(0, 0,
+ // (1 - marginPercentage[0] - marginPercentage[2]) * windowSize[0],
+ // (1 - marginPercentage[1] - marginPercentage[3]) * windowSize[1]);
+ //
+ // sCameraSurfaceRect.set(0, 0, cameraSurfaceSize[0], cameraSurfaceSize[1]);
+ //
+ // sSurface2PreviewScaleRectTransform.reset();
+
+ switch (scaleType) {
+ case ViewPort.CENTER_INSIDE:
+ CameraShould.fail("not support now");
+ break;
+ case ViewPort.FILL_CENTER:
+ result.set(marginPercentage[0] * windowSize[0],
+ marginPercentage[1] * windowSize[1],
+ (1 - marginPercentage[0] - marginPercentage[2]) * windowSize[0],
+ (1 - marginPercentage[1] - marginPercentage[3]) * windowSize[1]
+ );
+ return;
+ default:
+ CameraShould.fail("not support now");
+ }
+
+ // sSurface2PreviewScaleRectTransform.mapRect(sCameraShowRect, sCameraSurfaceRect);
+
+
+ }
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/MatrixUtils.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/MatrixUtils.java
new file mode 100644
index 000000000..956d00a5c
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/MatrixUtils.java
@@ -0,0 +1,92 @@
+//
+// Source code recreated from a .class file by IntelliJ IDEA
+// (powered by Fernflower decompiler)
+//
+
+package com.quark.quamera.util;
+
+import android.opengl.Matrix;
+import android.os.Build;
+import android.util.Size;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+public class MatrixUtils {
+ public static final int TYPE_FITXY = 0;
+ public static final int TYPE_CENTERCROP = 1;
+ public static final int TYPE_CENTERINSIDE = 2;
+ public static final int TYPE_FITSTART = 3;
+ public static final int TYPE_FITEND = 4;
+
+ private MatrixUtils() {
+ }
+
+ public static void getMatrix(float[] matrix, int type, int imgWidth, int imgHeight, int viewWidth, int viewHeight) {
+ if (imgHeight > 0 && imgWidth > 0 && viewWidth > 0 && viewHeight > 0) {
+ float[] projection = new float[16];
+ float[] camera = new float[16];
+ if (type == 0) {
+ Matrix.orthoM(projection, 0, -1.0F, 1.0F, -1.0F, 1.0F, 1.0F, 3.0F);
+ Matrix.setLookAtM(camera, 0, 0.0F, 0.0F, 1.0F, 0.0F, 0.0F, 0.0F, 0.0F, 1.0F, 0.0F);
+ Matrix.multiplyMM(matrix, 0, projection, 0, camera, 0);
+ return;
+ }
+
+ float sWhView = (float) viewWidth / (float) viewHeight;
+ float sWhImg = (float) imgWidth / (float) imgHeight;
+ if (sWhImg > sWhView) {
+ switch (type) {
+ case 1:
+ Matrix.orthoM(projection, 0, -sWhView / sWhImg, sWhView / sWhImg, -1.0F, 1.0F, 1.0F, 3.0F);
+ break;
+ case 2:
+ Matrix.orthoM(projection, 0, -1.0F, 1.0F, -sWhImg / sWhView, sWhImg / sWhView, 1.0F, 3.0F);
+ break;
+ case 3:
+ Matrix.orthoM(projection, 0, -1.0F, 1.0F, 1.0F - 2.0F * sWhImg / sWhView, 1.0F, 1.0F, 3.0F);
+ break;
+ case 4:
+ Matrix.orthoM(projection, 0, -1.0F, 1.0F, -1.0F, 2.0F * sWhImg / sWhView - 1.0F, 1.0F, 3.0F);
+ }
+ } else {
+ switch (type) {
+ case 1:
+ Matrix.orthoM(projection, 0, -1.0F, 1.0F, -sWhImg / sWhView, sWhImg / sWhView, 1.0F, 3.0F);
+ break;
+ case 2:
+ Matrix.orthoM(projection, 0, -sWhView / sWhImg, sWhView / sWhImg, -1.0F, 1.0F, 1.0F, 3.0F);
+ break;
+ case 3:
+ Matrix.orthoM(projection, 0, -1.0F, 2.0F * sWhView / sWhImg - 1.0F, -1.0F, 1.0F, 1.0F, 3.0F);
+ break;
+ case 4:
+ Matrix.orthoM(projection, 0, 1.0F - 2.0F * sWhView / sWhImg, 1.0F, -1.0F, 1.0F, 1.0F, 3.0F);
+ }
+ }
+
+ Matrix.setLookAtM(camera, 0, 0.0F, 0.0F, 1.0F, 0.0F, 0.0F, 0.0F, 0.0F, 1.0F, 0.0F);
+ Matrix.multiplyMM(matrix, 0, projection, 0, camera, 0);
+ }
+
+ }
+
+ public static float[] flip(float[] m, boolean x, boolean y) {
+ if (x || y) {
+ Matrix.scaleM(m, 0, x ? -1.0F : 1.0F, y ? -1.0F : 1.0F, 1.0F);
+ }
+
+ return m;
+ }
+
+ public static float[] flipF(float[] matrix, boolean x, boolean y) {
+ if (x || y) {
+ Matrix.scaleM(matrix, 0, x ? -1.0F : 1.0F, y ? -1.0F : 1.0F, 1.0F);
+ }
+
+ return matrix;
+ }
+
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/OpenGlUtils.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/OpenGlUtils.java
new file mode 100644
index 000000000..97590821c
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/OpenGlUtils.java
@@ -0,0 +1,60 @@
+package com.quark.quamera.util;
+
+import android.content.Context;
+import android.opengl.Matrix;
+
+import androidx.annotation.RestrictTo;
+
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+public class OpenGlUtils {
+
+
+ public static String readRawShaderFile(Context context, int shareId) {
+
+ BufferedReader br = null;
+ String line;
+ StringBuffer sb = new StringBuffer();
+ try {
+ InputStream is = context.getResources().openRawResource(shareId);
+ br = new BufferedReader(new InputStreamReader(is));
+ while ((line = br.readLine()) != null) {
+ sb.append(line);
+ sb.append("\n");
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ } finally {
+ IOUtils.safeClose(br);
+ }
+ return sb.toString();
+ }
+
+ public static float[] createIdentityMtx() {
+ float[] m = new float[16];
+ Matrix.setIdentityM(m, 0);
+ return m;
+ }
+
+ public static FloatBuffer createSquareVtx() {
+ float[] vtx = new float[]{
+ -1.0F, 1.0F, 0.0F, 0.0F, 1.0F, -1.0F, -1.0F, 0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 0.0F, 1.0F, 1.0F, 1.0F, -1.0F, 0.0F, 1.0F, 0.0F};
+ ByteBuffer bb = ByteBuffer.allocateDirect(4 * vtx.length);
+ bb.order(ByteOrder.nativeOrder());
+ FloatBuffer fb = bb.asFloatBuffer();
+ fb.put(vtx);
+ fb.position(0);
+ return fb;
+ }
+
+
+
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/Preconditions.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/Preconditions.java
new file mode 100644
index 000000000..1fa874800
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/Preconditions.java
@@ -0,0 +1,46 @@
+package com.quark.quamera.util;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-24
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import androidx.annotation.RestrictTo;
+
+//@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+public class Preconditions {
+
+
+ public static long CAMERA_THREAD_ID = -1;
+
+ public static void setCameraThread(long id) {
+ CAMERA_THREAD_ID = id;
+ }
+
+ public static void checkState(boolean state) {
+ if (!state) {
+ CameraShould.fail("");
+ }
+ }
+
+ public static void checkState(boolean state, String message) {
+ if (!state) {
+ CameraShould.fail(message);
+ }
+ }
+
+ public static void onException(Exception e) {
+ CameraShould.fail("", e);
+ }
+
+
+ public static void cameraThreadCheck() {
+ if (CAMERA_THREAD_ID != -1) {
+ if (Thread.currentThread().getId() != CAMERA_THREAD_ID) {
+ CameraShould.fail("");
+ }
+ }
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/SequentialExecutor.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/SequentialExecutor.java
new file mode 100644
index 000000000..9a4fd63c4
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/SequentialExecutor.java
@@ -0,0 +1,57 @@
+package com.quark.quamera.util;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-13
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.os.Handler;
+import android.os.HandlerThread;
+
+import androidx.annotation.RestrictTo;
+
+import java.util.concurrent.Executor;
+
+//@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+public class SequentialExecutor implements Executor {
+
+
+ private HandlerThread mHandlerThread;
+ private Handler mHandler;
+ private final String mName;
+
+ public SequentialExecutor(String name) {
+ mName = name;
+ }
+
+ public synchronized void start() {
+ mHandlerThread = new HandlerThread(mName);
+ mHandlerThread.start();
+ mHandler = new Handler(mHandlerThread.getLooper());
+ }
+
+ public synchronized void stop() {
+ if (mHandlerThread != null) {
+ mHandlerThread.quit();
+ mHandlerThread = null;
+ mHandler = null;
+ }
+ }
+
+ public Handler getHandler() {
+ if (mHandler == null) {
+ throw new RuntimeException("Start First");
+ }
+ return mHandler;
+ }
+
+ @Override
+ public synchronized void execute(Runnable command) {
+ if (mHandler == null) {
+ throw new RuntimeException("Executor （" + mName + ") Start First");
+ }
+ mHandler.post(command);
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/Should.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/Should.java
new file mode 100644
index 000000000..89924a0be
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/Should.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2004 - 2016 UCWeb Inc. All Rights Reserved.
+ * Creation : 2016/5/5
+ * Author : lzm89888@alibaba-inc.com
+ */
+
+package com.quark.quamera.util;
+
+import android.text.TextUtils;
+import android.util.Log;
+
+import androidx.annotation.RestrictTo;
+
+import java.util.Collection;
+
+
+/**
+ * 一个简单的断言工具
+ */
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+public class Should {
+ private static final String TAG = "Should";
+
+ public interface Logger {
+ void log(String message, Throwable tr);
+ }
+
+ public static class DefaultLogger implements Logger {
+ @Override
+ public void log(String message, Throwable tr) {
+ Log.e(TAG, message, tr);
+ }
+ }
+
+ private static boolean sShouldThrowError = true;
+ private static Logger sLogger = new DefaultLogger();
+
+ /**
+ * 设置当Should的条件不满足时是否抛出AssertionError, 如果设置为否，则当Should的条件不满足时，仅
+ * 输出error log, 不会抛出AssertionError
+ * 一般情况下，开发和内测版本设置抛出异常，正式和灰度版本为了产品的最大可用性，仅输出error log.
+ * @param enable 是否需要抛出AssertionError
+ */
+ public static void setThrowAssertionError(boolean enable) {
+ sShouldThrowError = enable;
+ }
+
+ public static void setLogger(Logger logger) {
+ sLogger = logger;
+ }
+
+ public static void notNull(Object obj) {
+ notNull(obj, "notNull assert fail");
+ }
+
+ public static void notNull(Object obj, String msg) {
+ notNullIf(obj, true, msg);
+ }
+
+ /**
+ * 在ifCondition为true的情况下，obj不应为null
+ */
+ public static void notNullIf(Object obj, boolean ifCondition) {
+ notNullIf(obj, ifCondition, "notNullIf assert fail");
+ }
+
+ public static void notNullIf(Object obj, boolean ifCondition, String msg) {
+ if(ifCondition && obj == null) {
+ throwAssertionError(msg);
+ }
+ }
+
+ private static void throwAssertionError(String msg) {
+ throwAssertionError(msg, null);
+ }
+
+ private static void throwAssertionError(String msg, Throwable t) {
+ if(sShouldThrowError) {
+ if(t != null) {
+ sLogger.log(msg, null);
+ throw new AssertionError(t);
+ } else {
+ throw new AssertionError(msg);
+ }
+ } else {
+ sLogger.log(msg, t != null ? t : new Throwable());
+ }
+ }
+
+ public static void beNullIf(Object obj, boolean ifCondition) {
+ beNullIf(obj, ifCondition, "beNullIf assert fail");
+ }
+
+ public static void beNullIf(Object obj, boolean ifCondition, String msg) {
+ if(ifCondition && obj != null) {
+ throwAssertionError(msg);
+ }
+ }
+
+ public static void notEmpty(CharSequence str) {
+ notEmptyIf(str, true, "notEmpty assert fail");
+ }
+
+ public static void notEmptyIf(CharSequence str, boolean ifCondition) {
+ notEmptyIf(str, ifCondition, "notEmptyIf assert fail");
+ }
+
+ public static void notEmptyIf(CharSequence str, boolean ifCondition, String msg) {
+ if (ifCondition && TextUtils.isEmpty(str)) {
+ throwAssertionError(msg);
+ }
+ }
+
+ public static void notEmpty(Collection c) {
+ notEmptyIf(c, true, "notEmpty assert fail");
+ }
+
+ public static void notEmptyIf(Collection c, boolean ifCondition, String msg) {
+ if (ifCondition && (c == null || c.isEmpty())) {
+ throwAssertionError(msg);
+ }
+ }
+
+ public static void beTrue(boolean b) {
+ beTrueIf(b, true);
+ }
+
+ public static void beTrue(boolean b, String msg) {
+ beTrueIf(b, true, msg);
+ }
+
+ /**
+ * 在ifCondition为true的情况下，断言b为true
+ */
+ public static void beTrueIf(boolean b, boolean ifCondition) {
+ beTrueIf(b, ifCondition, "beTrueIf assert fail");
+ }
+
+ public static void beTrueIf(boolean b, boolean ifCondition, String msg) {
+ if (ifCondition && !b ) {
+ throwAssertionError(msg);
+ }
+ }
+
+ public static void beFalse(boolean b, String msg) {
+ beFalseIf(b, true, msg);
+ }
+
+ public static void beFalse(boolean b) {
+ beFalseIf(b, true);
+ }
+
+ public static void beFalseIf(boolean b, boolean ifCondition) {
+ beFalseIf(b, ifCondition, "beFalseIf assert fail");
+ }
+
+ public static void beFalseIf(boolean b, boolean ifCondition, String msg) {
+ if (ifCondition && b) {
+ throwAssertionError(msg);
+ }
+ }
+
+ public static void fail() {
+ fail("assert fail");
+ }
+
+ public static void fail(String msg) {
+ throwAssertionError(msg);
+ }
+
+ public static void fail(String msg, Throwable t) {
+ throwAssertionError(msg, t);
+ }
+
+ public static void beEqual(int origin, int expect) {
+ if(sShouldThrowError) {
+ if (origin != expect) {
+ throwAssertionError("" + origin + " not equal to " + expect);
+ }
+ }
+ }
+}
diff --git a/mediapipe/render/android/camera/java/com/quark/quamera/util/TestOnly.java b/mediapipe/render/android/camera/java/com/quark/quamera/util/TestOnly.java
new file mode 100644
index 000000000..32d6e2b38
--- /dev/null
+++ b/mediapipe/render/android/camera/java/com/quark/quamera/util/TestOnly.java
@@ -0,0 +1,25 @@
+package com.quark.quamera.util;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.PACKAGE;
+import static java.lang.annotation.ElementType.TYPE;
+
+/**
+ * A method/constructor annotated with TestOnly claims that it should be called from testing code only.
+ *
+ * Apart from documentation purposes this annotation is intended to be used by static analysis tools
+ * to validate against element contract violations.
+ */
+@Documented
+@Retention(RetentionPolicy.SOURCE)
+@Target({PACKAGE, TYPE, ANNOTATION_TYPE, CONSTRUCTOR, METHOD, FIELD})
+public @interface TestOnly {
+}
diff --git a/mediapipe/render/demo/android/java/com/quark/quamerademo/ActivityCameraSession.java b/mediapipe/render/demo/android/java/com/quark/quamerademo/ActivityCameraSession.java
new file mode 100644
index 000000000..feeff452c
--- /dev/null
+++ b/mediapipe/render/demo/android/java/com/quark/quamerademo/ActivityCameraSession.java
@@ -0,0 +1,306 @@
+package com.quark.quamerademo;
+/*
+ * Copyright (C) 2005-2019 UCWeb Inc. All rights reserved.
+ * Description :
+ *
+ * Creation : 20-11-25
+ * Author : jiaming.wjm@alibaba-inc.com
+ */
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Matrix;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.SystemClock;
+import android.util.Log;
+import android.util.Size;
+import android.view.Surface;
+
+import androidx.annotation.GuardedBy;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+import androidx.lifecycle.MutableLiveData;
+import androidx.lifecycle.Observer;
+
+
+import com.quark.quamera.camera.Camera2Manager;
+import com.quark.quamera.camera.camera.CameraState;
+import com.quark.quamera.camera.concurrent.MainThreadExecutor;
+import com.quark.quamera.camera.preview.IPreviewSurfaceProvider;
+import com.quark.quamera.camera.preview.IPreviewView;
+import com.quark.quamera.camera.preview.SurfaceTextureWrapper;
+import com.quark.quamera.camera.session.CameraCaptureCallback;
+import com.quark.quamera.camera.session.CameraCaptureCallbackHandlerWrapper;
+import com.quark.quamera.camera.session.CameraCaptureResult;
+import com.quark.quamera.camera.session.CameraSelector;
+import com.quark.quamera.camera.session.PreviewConfig;
+import com.quark.quamera.camera.session.SessionConfig;
+import com.quark.quamera.camera.session.UserCameraSession;
+import com.quark.quamera.render.DefaultCameraRender;
+import com.quark.quamera.render.detector.IAlgTextureConsumer;
+import com.quark.quamera.render.photo.ExportPhoto;
+import com.quark.quamera.render.photo.SnapShotCommand;
+import com.quark.quamera.render.view.CameraVideoView;
+
+import java.nio.ByteBuffer;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+public class ActivityCameraSession {
+
+
+ //Run in main thread
+ private UserCameraSession mUserCameraSession;
+
+ private CameraVideoView mPreview;
+
+ private final Context mContext;
+
+ private CameraSelector.CameraLenFacing mCameraLenFacing = CameraSelector.CameraLenFacing.LEN_FACING_BACK;
+
+
+ private boolean mIsActive;
+
+
+ private final AtomicBoolean mDoingSnapshot = new AtomicBoolean(false);
+
+
+ private boolean mFirstStartCamera = true;
+
+ private final Object mSurfaceLock = new Object();
+ @GuardedBy("mSurfaceLock")
+ private DefaultCameraRender mDefaultCameraRender;
+
+
+ public ActivityCameraSession(@NonNull Context context) {
+ mContext = context;
+ }
+
+
+ public void onWindowCreate() {
+ requestCameraSession(mCameraLenFacing);
+ }
+
+ public void onWindowActive() {
+ mIsActive = true;
+ processCameraSessionActive();
+ }
+
+ private void processCameraSessionActive() {
+ long start = SystemClock.elapsedRealtime();
+ if (mUserCameraSession == null || !mUserCameraSession.active()) {
+ return;
+ }
+ if (!mFirstStartCamera) {
+ return;
+ }
+ MutableLiveData cameraStateObservable = mUserCameraSession.getCameraState();
+
+ if (cameraStateObservable == null) {
+ return;
+ }
+ cameraStateObservable.observeForever(new Observer() {
+ @Override
+ public void onChanged(CameraState cameraState) {
+ if (cameraState == CameraState.OPEN) {
+ Log.i("CameraMainWindow", "camera open time " + (SystemClock.elapsedRealtime() - start));
+ cameraStateObservable.removeObserver(this);
+ }
+ }
+ });
+ mFirstStartCamera = false;
+ }
+
+
+ public void onWindowInactive() {
+ mIsActive = false;
+ if (mUserCameraSession != null && mUserCameraSession.inactive()) {
+// mRepository.onInactive(this);
+ mDoingSnapshot.set(false);
+ }
+ }
+
+ public void onWindowDestroy() {
+ onWindowInactive();
+ }
+
+
+ public void takePhoto() {
+ if (mDoingSnapshot.get()) {
+ return;
+ }
+ mDoingSnapshot.set(true);
+ if (mPreview == null) {
+ return;
+ }
+ long start = SystemClock.elapsedRealtime();
+
+
+ SnapShotCommand snapShotCommand = new SnapShotCommand(0, 0, 1f, 1f, value -> {
+ if (value == null || value.data == null) {
+ return;
+ }
+ Bitmap bitmap = convertGLPixels2BitmapCache(value);
+
+ mDoingSnapshot.set(false);
+
+
+ });
+ mPreview.snapshot(snapShotCommand);
+
+ }
+
+
+ public static Bitmap convertGLPixels2BitmapCache(ExportPhoto input) {
+ if (input == null || !input.isValid()) {
+ return null;
+ }
+
+ int width = input.width;
+ int height = input.height;
+
+ int totalLength = width * height * 4; //int = 4 bytes
+
+ if (input.data == null || input.width == 0 || input.height == 0 || input.data.length < totalLength) {
+ return null;
+ }
+
+ ByteBuffer buf = ByteBuffer.wrap(input.data);
+
+
+ Bitmap result = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+ result.copyPixelsFromBuffer(buf);
+
+ Matrix yFlip = new Matrix();
+ //ARGB为从GL上读出来的数据，所以Y轴要上下翻转，GL坐标系和Bitmap坐标系问题
+ yFlip.postScale(1, -1);
+ return Bitmap.createBitmap(result, 0, 0, result.getWidth(), result.getHeight(), yFlip, false);
+ }
+
+
+ public void setCameraPreview(@NonNull CameraVideoView cameraPreview) {
+ mPreview = cameraPreview;
+// mPreview.setOnAlgCpuDataReceiver(mPreviewDataCallback);
+ setPreviewDataCallback(mPreviewDataCallback);
+ }
+
+ private final IPreviewSurfaceProvider mPreviewSurfaceProvider = new IPreviewSurfaceProvider() {
+
+ @Override
+ public Surface provide(@NonNull SurfaceRequest request) {
+ synchronized (mSurfaceLock) {
+ //释放当前surface texture
+ onUseComplete(null);
+
+ Log.i("CameraMainWindow", "provide surface texture");
+
+ SurfaceTextureWrapper surfaceTextureWrapper = new SurfaceTextureWrapper(request.width, request.height);
+ mDefaultCameraRender = new DefaultCameraRender(surfaceTextureWrapper, request.camera2Camera, request.repeatCaptureCallback);
+
+ if (mPreview != null) {
+ mPreview.getRender().setCameraRender(mDefaultCameraRender);
+ }
+
+ return surfaceTextureWrapper.getSurface();
+ }
+ }
+
+// @Override
+// public Surface provide(int width, int height) {
+// synchronized (mSurfaceLock) {
+// //释放当前surface texture
+// onUseComplete(null);
+//
+// Log.i("CameraMainWindow", "provide surface texture");
+//
+// SurfaceTextureWrapper surfaceTextureWrapper = new SurfaceTextureWrapper(width, height);
+// mDefaultCameraRender = new DefaultCameraRender(surfaceTextureWrapper);
+//
+// if (mPreview != null) {
+// mPreview.getRender().setCameraRender(mDefaultCameraRender);
+// }
+//
+// return surfaceTextureWrapper.getSurface();
+// }
+// }
+
+ @Override
+ public void onUseComplete(Surface surface) {
+ synchronized (mSurfaceLock) {
+ if (mDefaultCameraRender != null) {
+ Log.i("CameraMainWindow", "onReleaseUseComplete");
+ mDefaultCameraRender.destroySurface();
+ mDefaultCameraRender = null;
+ }
+ }
+ }
+ };
+
+
+ private void requestCameraSession(CameraSelector.CameraLenFacing lenFacing) {
+
+ Camera2Manager.getInstance(mContext)
+ .addListener(result -> {
+ Size size = new Size(720 * 16 / 9, 720);
+ PreviewConfig previewConfig = new PreviewConfig(size.getWidth(), size.getHeight(), mPreview);
+// previewConfig.setRepeatCaptureCallback(new CameraCaptureCallback() {
+// @Override
+// public void onCaptureCompleted(@NonNull CameraCaptureResult cameraCaptureResult) {
+// }
+// }, MainThreadExecutor.getInstance());
+
+
+ SessionConfig sessionConfig = new SessionConfig(previewConfig);
+ sessionConfig.setCameraErrorListener((cameraError, message) -> {
+ Log.e("CameraMainWindow", "ERROR!!!: " + cameraError + " : " + message);
+ }, null);
+
+ mUserCameraSession = result.requestCameraSession(sessionConfig);
+ mUserCameraSession
+ .setCameraSelector(new CameraSelector().setFacing(lenFacing));
+
+
+ if (mIsActive) {
+ processCameraSessionActive();
+ } else {
+ mUserCameraSession.inactive();
+ }
+
+ }, MainThreadExecutor.getInstance());
+ }
+
+
+ public void enableFlash(boolean enable, CameraCaptureCallback callback) {
+ if (mUserCameraSession != null) {
+ mUserCameraSession.enableFlash(
+ enable,
+ callback != null ? new CameraCaptureCallbackHandlerWrapper(new Handler(Looper.getMainLooper()), callback) : null,
+ null);
+ }
+ }
+
+
+ public void switchCamera(@NonNull CameraSelector.CameraLenFacing cameraLenFacing) {
+ CameraSelector.CameraLenFacing lastCameraLenFacing = mCameraLenFacing;
+ mCameraLenFacing = cameraLenFacing;
+
+ if (mUserCameraSession != null
+ && mUserCameraSession.isActive()
+ && mCameraLenFacing != lastCameraLenFacing) {
+ mUserCameraSession.inactive();
+ requestCameraSession(mCameraLenFacing);
+ }
+ }
+
+
+ private IAlgTextureConsumer.OnAlgCpuDataReceiver mPreviewDataCallback;
+
+ public void setPreviewDataCallback(IAlgTextureConsumer.OnAlgCpuDataReceiver previewDataCallback) {
+ mPreviewDataCallback = previewDataCallback;
+// if (mPreview != null) {
+// mPreview.setOnAlgCpuDataReceiver(mPreviewDataCallback);
+// }
+ }
+}
diff --git a/mediapipe/render/demo/android/java/com/quark/quamerademo/AndroidManifest.xml b/mediapipe/render/demo/android/java/com/quark/quamerademo/AndroidManifest.xml
new file mode 100644
index 000000000..18ea30302
--- /dev/null
+++ b/mediapipe/render/demo/android/java/com/quark/quamerademo/AndroidManifest.xml
@@ -0,0 +1,36 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/mediapipe/render/demo/android/java/com/quark/quamerademo/BUILD b/mediapipe/render/demo/android/java/com/quark/quamerademo/BUILD
new file mode 100644
index 000000000..1be8863b7
--- /dev/null
+++ b/mediapipe/render/demo/android/java/com/quark/quamerademo/BUILD
@@ -0,0 +1,45 @@
+# Copyright 2020 The MediaPipe Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+licenses(["notice"])
+
+package(default_visibility = ["//visibility:private"])
+
+cc_binary(
+ name = "libola_render_jni.so",
+ linkshared = 1,
+ linkstatic = 1,
+ srcs = [
+ "//mediapipe/render/module/render_queue:olarender",
+ ],
+)
+
+cc_library(
+ name = "ola_render_jni_lib",
+ srcs = [":libola_render_jni.so"],
+ alwayslink = 1,
+)
+
+android_binary(
+ name = "quamerademo",
+ srcs = glob(["*.java"]),
+ assets = [],
+ assets_dir = "",
+ manifest = "//mediapipe/render/demo/android/java/com/quark/quamerademo:AndroidManifest.xml",
+ multidex = "native",
+ deps = [
+ ":ola_render_jni_lib",
+ "//mediapipe/java/com/google/mediapipe/framework:android_framework",
+ ],
+)
diff --git a/mediapipe/render/demo/android/java/com/quark/quamerademo/MainActivity.java b/mediapipe/render/demo/android/java/com/quark/quamerademo/MainActivity.java
new file mode 100644
index 000000000..7ff9d0187
--- /dev/null
+++ b/mediapipe/render/demo/android/java/com/quark/quamerademo/MainActivity.java
@@ -0,0 +1,84 @@
+package com.quark.quamerademo;
+
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+
+import android.Manifest;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+
+import com.quark.quamera.render.view.CameraVideoView;
+
+public class MainActivity extends AppCompatActivity {
+
+ private CameraVideoView mCameraVideoView;
+ private ActivityCameraSession mActivityCameraSession;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ mCameraVideoView = new CameraVideoView(this, null);
+ setContentView(mCameraVideoView);
+ mActivityCameraSession = new ActivityCameraSession(this);
+ mActivityCameraSession.setCameraPreview(mCameraVideoView);
+ requestPermission(() -> mActivityCameraSession.onWindowCreate());
+ }
+
+
+ private Runnable mPermissionCacheRunnable;
+
+
+ public static final int REQUEST_CODE = 1234;
+
+ public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+ super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+ if (requestCode == REQUEST_CODE) {
+ if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+ if (mPermissionCacheRunnable != null) {
+ mPermissionCacheRunnable.run();
+ mPermissionCacheRunnable = null;
+ }
+ } else {
+ finish();
+ }
+ }
+ }
+
+
+ @Override
+ protected void onResume() {
+ super.onResume();
+
+ mActivityCameraSession.onWindowActive();
+ }
+
+ @Override
+ protected void onPause() {
+ super.onPause();
+ mActivityCameraSession.onWindowInactive();
+ }
+
+ @Override
+ protected void onDestroy() {
+ super.onDestroy();
+ mActivityCameraSession.onWindowDestroy();
+ }
+
+ /**
+ * 请求授权
+ */
+ private void requestPermission(Runnable runnable) {
+
+ if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) { //表示未授权时
+ //进行授权
+ ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA}, REQUEST_CODE);
+ mPermissionCacheRunnable = runnable;
+ } else {
+ runnable.run();
+ }
+ }
+
+
+}
\ No newline at end of file
diff --git a/mediapipe/render/module/beauty/android/framework/AndroidManifest.xml b/mediapipe/render/module/beauty/android/framework/AndroidManifest.xml
new file mode 100644
index 000000000..5a1f8ccd0
--- /dev/null
+++ b/mediapipe/render/module/beauty/android/framework/AndroidManifest.xml
@@ -0,0 +1,9 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/mediapipe/render/module/beauty/android/framework/jni_hooks.cpp b/mediapipe/render/module/beauty/android/framework/jni_hooks.cpp
new file mode 100644
index 000000000..65fa631be
--- /dev/null
+++ b/mediapipe/render/module/beauty/android/framework/jni_hooks.cpp
@@ -0,0 +1,11 @@
+//
+// Created by jormin on 2021/4/3.
+//
+
+#include
+
+extern "C" {
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) {
+ return JNI_VERSION_1_6;
+}
+}
\ No newline at end of file
diff --git a/mediapipe/render/module/beauty/android/framework/opengl_renderer_jni.cpp b/mediapipe/render/module/beauty/android/framework/opengl_renderer_jni.cpp
new file mode 100644
index 000000000..3bbf30e08
--- /dev/null
+++ b/mediapipe/render/module/beauty/android/framework/opengl_renderer_jni.cpp
@@ -0,0 +1,583 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+namespace {
+ auto constexpr LOG_TAG = "OpenGLRendererJni";
+
+ std::string GLErrorString(GLenum error) {
+ switch (error) {
+ case GL_NO_ERROR:
+ return "GL_NO_ERROR";
+ case GL_INVALID_ENUM:
+ return "GL_INVALID_ENUM";
+ case GL_INVALID_VALUE:
+ return "GL_INVALID_VALUE";
+ case GL_INVALID_OPERATION:
+ return "GL_INVALID_OPERATION";
+ case GL_STACK_OVERFLOW_KHR:
+ return "GL_STACK_OVERFLOW";
+ case GL_STACK_UNDERFLOW_KHR:
+ return "GL_STACK_UNDERFLOW";
+ case GL_OUT_OF_MEMORY:
+ return "GL_OUT_OF_MEMORY";
+ case GL_INVALID_FRAMEBUFFER_OPERATION:
+ return "GL_INVALID_FRAMEBUFFER_OPERATION";
+ default: {
+ std::ostringstream oss;
+ oss << "";
+ return oss.str();
+ }
+ }
+ }
+
+ std::string EGLErrorString(EGLenum error) {
+ switch (error) {
+ case EGL_SUCCESS:
+ return "EGL_SUCCESS";
+ case EGL_NOT_INITIALIZED:
+ return "EGL_NOT_INITIALIZED";
+ case EGL_BAD_ACCESS:
+ return "EGL_BAD_ACCESS";
+ case EGL_BAD_ALLOC:
+ return "EGL_BAD_ALLOC";
+ case EGL_BAD_ATTRIBUTE:
+ return "EGL_BAD_ATTRIBUTE";
+ case EGL_BAD_CONTEXT:
+ return "EGL_BAD_CONTEXT";
+ case EGL_BAD_CONFIG:
+ return "EGL_BAD_CONFIG";
+ case EGL_BAD_CURRENT_SURFACE:
+ return "EGL_BAD_CURRENT_SURFACE";
+ case EGL_BAD_DISPLAY:
+ return "EGL_BAD_DISPLAY";
+ case EGL_BAD_SURFACE:
+ return "EGL_BAD_SURFACE";
+ case EGL_BAD_MATCH:
+ return "EGL_BAD_MATCH";
+ case EGL_BAD_PARAMETER:
+ return "EGL_BAD_PARAMETER";
+ case EGL_BAD_NATIVE_PIXMAP:
+ return "EGL_BAD_NATIVE_PIXMAP";
+ case EGL_BAD_NATIVE_WINDOW:
+ return "EGL_BAD_NATIVE_WINDOW";
+ case EGL_CONTEXT_LOST:
+ return "EGL_CONTEXT_LOST";
+ default: {
+ std::ostringstream oss;
+ oss << "";
+ return oss.str();
+ }
+ }
+ }
+}
+
+#ifdef NDEBUG
+#define CHECK_GL(gl_func) [&]() { return gl_func; }()
+#else
+namespace {
+ class CheckGlErrorOnExit {
+ public:
+ explicit CheckGlErrorOnExit(std::string glFunStr, unsigned int lineNum) :
+ mGlFunStr(std::move(glFunStr)),
+ mLineNum(lineNum) {}
+
+ ~CheckGlErrorOnExit() {
+ GLenum err = glGetError();
+ if (err != GL_NO_ERROR) {
+ __android_log_assert(nullptr, LOG_TAG, "OpenGL Error: %s at %s [%s:%d]",
+ GLErrorString(err).c_str(), mGlFunStr.c_str(), __FILE__,
+ mLineNum);
+ }
+ }
+ //TODO 看看为什么C++ 11的delete 禁止不生效
+//
+// CheckGlErrorOnExit(const CheckGlErrorOnExit &) = delete;
+//
+// CheckGlErrorOnExit &operator=(const CheckGlErrorOnExit &) = delete;
+
+ private:
+ std::string mGlFunStr;
+ unsigned int mLineNum;
+ }; // class CheckGlErrorOnExit
+} // namespace
+#define CHECK_GL(glFunc) \
+ [&]() { \
+ auto assertOnExit = CheckGlErrorOnExit(#glFunc, __LINE__); \
+ return glFunc; \
+ }()
+#endif
+
+namespace {
+ constexpr char VERTEX_SHADER_SRC[] = R"SRC(
+ attribute vec4 position;
+ attribute vec4 texCoords;
+ uniform mat4 mvpTransform;
+ uniform mat4 texTransform;
+ varying vec2 fragCoord;
+ void main() {
+ fragCoord = (texTransform * texCoords).xy;
+ gl_Position = mvpTransform * position;
+ }
+)SRC";
+
+ constexpr char FRAGMENT_SHADER_SRC[] = R"SRC(
+ #extension GL_OES_EGL_image_external : require
+ precision mediump float;
+ uniform samplerExternalOES sampler;
+ varying vec2 fragCoord;
+ void main() {
+ gl_FragColor = vec4(texture2D(sampler, fragCoord).r,1.0,0.0,1.0);
+ }
+)SRC";
+
+ struct NativeContext {
+ EGLDisplay display;
+ EGLConfig config;
+ EGLContext context;
+ std::pair windowSurface;
+ EGLSurface pbufferSurface;
+ GLuint program;
+ GLint positionHandle;
+ GLint texCoordsHandle;
+ GLint samplerHandle;
+ GLint mvpTransformHandle;
+ GLint texTransformHandle;
+ GLuint textureId;
+
+ NativeContext(EGLDisplay display, EGLConfig config, EGLContext context,
+ ANativeWindow *window, EGLSurface surface,
+ EGLSurface pbufferSurface)
+ : display(display),
+ config(config),
+ context(context),
+ windowSurface(std::make_pair(window, surface)),
+ pbufferSurface(pbufferSurface),
+ program(0),
+ positionHandle(-1),
+ texCoordsHandle(1),
+ samplerHandle(-1),
+ mvpTransformHandle(-1),
+ texTransformHandle(-1),
+ textureId(0) {}
+ };
+
+ const char *ShaderTypeString(GLenum shaderType) {
+ switch (shaderType) {
+ case GL_VERTEX_SHADER:
+ return "GL_VERTEX_SHADER";
+ case GL_FRAGMENT_SHADER:
+ return "GL_FRAGMENT_SHADER";
+ default:
+ return "";
+ }
+ }
+
+ // Returns a handle to the shader
+ GLuint CompileShader(GLenum shaderType, const char *shaderSrc) {
+ GLuint shader = CHECK_GL(glCreateShader(shaderType));
+ assert(shader);
+ CHECK_GL(glShaderSource(shader, 1, &shaderSrc, /*length=*/nullptr));
+ CHECK_GL(glCompileShader(shader));
+ GLint compileStatus = 0;
+ CHECK_GL(glGetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus));
+ if (!compileStatus) {
+ GLint logLength = 0;
+ CHECK_GL(glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength));
+ std::vector