/* * Copyright (C) 2011 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.android.camera; import android.annotation.TargetApi; import android.content.Context; import android.graphics.SurfaceTexture; import android.hardware.Camera; import android.media.CamcorderProfile; import android.media.MediaRecorder; import android.os.Handler; import android.os.Looper; import android.util.Log; import com.android.gallery3d.common.ApiHelper; import java.io.FileDescriptor; import java.io.IOException; import java.io.Serializable; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /** * Encapsulates the mobile filter framework components needed to record video * with effects applied. Modeled after MediaRecorder. */ @TargetApi(ApiHelper.VERSION_CODES.HONEYCOMB) // uses SurfaceTexture public class EffectsRecorder { private static final String TAG = "EffectsRecorder"; private static Class sClassFilter; private static Method sFilterIsAvailable; private static EffectsRecorder sEffectsRecorder; // The index of the current effects recorder. private static int sEffectsRecorderIndex; private static boolean sReflectionInited = false; private static Class sClsLearningDoneListener; private static Class sClsOnRunnerDoneListener; private static Class sClsOnRecordingDoneListener; private static Class sClsSurfaceTextureSourceListener; private static Method sFilterSetInputValue; private static Constructor sCtPoint; private static Constructor sCtQuad; private static Method sLearningDoneListenerOnLearningDone; private static Method sObjectEquals; private static Method sObjectToString; private static Class sClsGraphRunner; private static Method sGraphRunnerGetGraph; private static Method sGraphRunnerSetDoneCallback; private static Method sGraphRunnerRun; private static Method sGraphRunnerGetError; private static Method sGraphRunnerStop; private static Method sFilterGraphGetFilter; private static Method sFilterGraphTearDown; private static Method sOnRunnerDoneListenerOnRunnerDone; private static Class sClsGraphEnvironment; private static Constructor sCtGraphEnvironment; private static Method sGraphEnvironmentCreateGLEnvironment; private static Method sGraphEnvironmentGetRunner; private static Method sGraphEnvironmentAddReferences; private static Method sGraphEnvironmentLoadGraph; private static Method sGraphEnvironmentGetContext; private static Method sFilterContextGetGLEnvironment; private static Method sGLEnvironmentIsActive; private static Method sGLEnvironmentActivate; private static Method sGLEnvironmentDeactivate; private static Method sSurfaceTextureTargetDisconnect; private static Method sOnRecordingDoneListenerOnRecordingDone; private static Method sSurfaceTextureSourceListenerOnSurfaceTextureSourceReady; private Object mLearningDoneListener; private Object mRunnerDoneCallback; private Object mSourceReadyCallback; // A callback to finalize the media after the recording is done. private Object mRecordingDoneListener; static { try { sClassFilter = Class.forName("android.filterfw.core.Filter"); sFilterIsAvailable = sClassFilter.getMethod("isAvailable", String.class); } catch (ClassNotFoundException ex) { Log.v(TAG, "Can't find the class android.filterfw.core.Filter"); } catch (NoSuchMethodException e) { Log.v(TAG, "Can't find the method Filter.isAvailable"); } } public static final int EFFECT_NONE = 0; public static final int EFFECT_GOOFY_FACE = 1; public static final int EFFECT_BACKDROPPER = 2; public static final int EFFECT_GF_SQUEEZE = 0; public static final int EFFECT_GF_BIG_EYES = 1; public static final int EFFECT_GF_BIG_MOUTH = 2; public static final int EFFECT_GF_SMALL_MOUTH = 3; public static final int EFFECT_GF_BIG_NOSE = 4; public static final int EFFECT_GF_SMALL_EYES = 5; public static final int NUM_OF_GF_EFFECTS = EFFECT_GF_SMALL_EYES + 1; public static final int EFFECT_MSG_STARTED_LEARNING = 0; public static final int EFFECT_MSG_DONE_LEARNING = 1; public static final int EFFECT_MSG_SWITCHING_EFFECT = 2; public static final int EFFECT_MSG_EFFECTS_STOPPED = 3; public static final int EFFECT_MSG_RECORDING_DONE = 4; public static final int EFFECT_MSG_PREVIEW_RUNNING = 5; private Context mContext; private Handler mHandler; private CameraManager.CameraProxy mCameraDevice; private CamcorderProfile mProfile; private double mCaptureRate = 0; private SurfaceTexture mPreviewSurfaceTexture; private int mPreviewWidth; private int mPreviewHeight; private MediaRecorder.OnInfoListener mInfoListener; private MediaRecorder.OnErrorListener mErrorListener; private String mOutputFile; private FileDescriptor mFd; private int mOrientationHint = 0; private long mMaxFileSize = 0; private int mMaxDurationMs = 0; private int mCameraFacing = Camera.CameraInfo.CAMERA_FACING_BACK; private int mCameraDisplayOrientation; private int mEffect = EFFECT_NONE; private int mCurrentEffect = EFFECT_NONE; private EffectsListener mEffectsListener; private Object mEffectParameter; private Object mGraphEnv; private int mGraphId; private Object mRunner = null; private Object mOldRunner = null; private SurfaceTexture mTextureSource; private static final int STATE_CONFIGURE = 0; private static final int STATE_WAITING_FOR_SURFACE = 1; private static final int STATE_STARTING_PREVIEW = 2; private static final int STATE_PREVIEW = 3; private static final int STATE_RECORD = 4; private static final int STATE_RELEASED = 5; private int mState = STATE_CONFIGURE; private boolean mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE); private SoundClips.Player mSoundPlayer; /** Determine if a given effect is supported at runtime * Some effects require libraries not available on all devices */ public static boolean isEffectSupported(int effectId) { if (sFilterIsAvailable == null) return false; try { switch (effectId) { case EFFECT_GOOFY_FACE: return (Boolean) sFilterIsAvailable.invoke(null, "com.google.android.filterpacks.facedetect.GoofyRenderFilter"); case EFFECT_BACKDROPPER: return (Boolean) sFilterIsAvailable.invoke(null, "android.filterpacks.videoproc.BackDropperFilter"); default: return false; } } catch (Exception ex) { Log.e(TAG, "Fail to check filter", ex); } return false; } public EffectsRecorder(Context context) { if (mLogVerbose) Log.v(TAG, "EffectsRecorder created (" + this + ")"); if (!sReflectionInited) { try { sFilterSetInputValue = sClassFilter.getMethod("setInputValue", new Class[] {String.class, Object.class}); Class clsPoint = Class.forName("android.filterfw.geometry.Point"); sCtPoint = clsPoint.getConstructor(new Class[] {float.class, float.class}); Class clsQuad = Class.forName("android.filterfw.geometry.Quad"); sCtQuad = clsQuad.getConstructor(new Class[] {clsPoint, clsPoint, clsPoint, clsPoint}); Class clsBackDropperFilter = Class.forName( "android.filterpacks.videoproc.BackDropperFilter"); sClsLearningDoneListener = Class.forName( "android.filterpacks.videoproc.BackDropperFilter$LearningDoneListener"); sLearningDoneListenerOnLearningDone = sClsLearningDoneListener .getMethod("onLearningDone", new Class[] {clsBackDropperFilter}); sObjectEquals = Object.class.getMethod("equals", new Class[] {Object.class}); sObjectToString = Object.class.getMethod("toString"); sClsOnRunnerDoneListener = Class.forName( "android.filterfw.core.GraphRunner$OnRunnerDoneListener"); sOnRunnerDoneListenerOnRunnerDone = sClsOnRunnerDoneListener.getMethod( "onRunnerDone", new Class[] {int.class}); sClsGraphRunner = Class.forName("android.filterfw.core.GraphRunner"); sGraphRunnerGetGraph = sClsGraphRunner.getMethod("getGraph"); sGraphRunnerSetDoneCallback = sClsGraphRunner.getMethod( "setDoneCallback", new Class[] {sClsOnRunnerDoneListener}); sGraphRunnerRun = sClsGraphRunner.getMethod("run"); sGraphRunnerGetError = sClsGraphRunner.getMethod("getError"); sGraphRunnerStop = sClsGraphRunner.getMethod("stop"); Class clsFilterContext = Class.forName("android.filterfw.core.FilterContext"); sFilterContextGetGLEnvironment = clsFilterContext.getMethod( "getGLEnvironment"); Class clsFilterGraph = Class.forName("android.filterfw.core.FilterGraph"); sFilterGraphGetFilter = clsFilterGraph.getMethod("getFilter", new Class[] {String.class}); sFilterGraphTearDown = clsFilterGraph.getMethod("tearDown", new Class[] {clsFilterContext}); sClsGraphEnvironment = Class.forName("android.filterfw.GraphEnvironment"); sCtGraphEnvironment = sClsGraphEnvironment.getConstructor(); sGraphEnvironmentCreateGLEnvironment = sClsGraphEnvironment.getMethod( "createGLEnvironment"); sGraphEnvironmentGetRunner = sClsGraphEnvironment.getMethod( "getRunner", new Class[] {int.class, int.class}); sGraphEnvironmentAddReferences = sClsGraphEnvironment.getMethod( "addReferences", new Class[] {Object[].class}); sGraphEnvironmentLoadGraph = sClsGraphEnvironment.getMethod( "loadGraph", new Class[] {Context.class, int.class}); sGraphEnvironmentGetContext = sClsGraphEnvironment.getMethod( "getContext"); Class clsGLEnvironment = Class.forName("android.filterfw.core.GLEnvironment"); sGLEnvironmentIsActive = clsGLEnvironment.getMethod("isActive"); sGLEnvironmentActivate = clsGLEnvironment.getMethod("activate"); sGLEnvironmentDeactivate = clsGLEnvironment.getMethod("deactivate"); Class clsSurfaceTextureTarget = Class.forName( "android.filterpacks.videosrc.SurfaceTextureTarget"); sSurfaceTextureTargetDisconnect = clsSurfaceTextureTarget.getMethod( "disconnect", new Class[] {clsFilterContext}); sClsOnRecordingDoneListener = Class.forName( "android.filterpacks.videosink.MediaEncoderFilter$OnRecordingDoneListener"); sOnRecordingDoneListenerOnRecordingDone = sClsOnRecordingDoneListener.getMethod("onRecordingDone"); sClsSurfaceTextureSourceListener = Class.forName( "android.filterpacks.videosrc.SurfaceTextureSource$SurfaceTextureSourceListener"); sSurfaceTextureSourceListenerOnSurfaceTextureSourceReady = sClsSurfaceTextureSourceListener.getMethod( "onSurfaceTextureSourceReady", new Class[] {SurfaceTexture.class}); } catch (Exception ex) { throw new RuntimeException(ex); } sReflectionInited = true; } sEffectsRecorderIndex++; Log.v(TAG, "Current effects recorder index is " + sEffectsRecorderIndex); sEffectsRecorder = this; SerializableInvocationHandler sih = new SerializableInvocationHandler( sEffectsRecorderIndex); mLearningDoneListener = Proxy.newProxyInstance( sClsLearningDoneListener.getClassLoader(), new Class[] {sClsLearningDoneListener}, sih); mRunnerDoneCallback = Proxy.newProxyInstance( sClsOnRunnerDoneListener.getClassLoader(), new Class[] {sClsOnRunnerDoneListener}, sih); mSourceReadyCallback = Proxy.newProxyInstance( sClsSurfaceTextureSourceListener.getClassLoader(), new Class[] {sClsSurfaceTextureSourceListener}, sih); mRecordingDoneListener = Proxy.newProxyInstance( sClsOnRecordingDoneListener.getClassLoader(), new Class[] {sClsOnRecordingDoneListener}, sih); mContext = context; mHandler = new Handler(Looper.getMainLooper()); mSoundPlayer = SoundClips.getPlayer(context); } public synchronized void setCamera(CameraManager.CameraProxy cameraDevice) { switch (mState) { case STATE_PREVIEW: throw new RuntimeException("setCamera cannot be called while previewing!"); case STATE_RECORD: throw new RuntimeException("setCamera cannot be called while recording!"); case STATE_RELEASED: throw new RuntimeException("setCamera called on an already released recorder!"); default: break; } mCameraDevice = cameraDevice; } public void setProfile(CamcorderProfile profile) { switch (mState) { case STATE_RECORD: throw new RuntimeException("setProfile cannot be called while recording!"); case STATE_RELEASED: throw new RuntimeException("setProfile called on an already released recorder!"); default: break; } mProfile = profile; } public void setOutputFile(String outputFile) { switch (mState) { case STATE_RECORD: throw new RuntimeException("setOutputFile cannot be called while recording!"); case STATE_RELEASED: throw new RuntimeException("setOutputFile called on an already released recorder!"); default: break; } mOutputFile = outputFile; mFd = null; } public void setOutputFile(FileDescriptor fd) { switch (mState) { case STATE_RECORD: throw new RuntimeException("setOutputFile cannot be called while recording!"); case STATE_RELEASED: throw new RuntimeException("setOutputFile called on an already released recorder!"); default: break; } mOutputFile = null; mFd = fd; } /** * Sets the maximum filesize (in bytes) of the recording session. * This will be passed on to the MediaEncoderFilter and then to the * MediaRecorder ultimately. If zero or negative, the MediaRecorder will * disable the limit */ public synchronized void setMaxFileSize(long maxFileSize) { switch (mState) { case STATE_RECORD: throw new RuntimeException("setMaxFileSize cannot be called while recording!"); case STATE_RELEASED: throw new RuntimeException( "setMaxFileSize called on an already released recorder!"); default: break; } mMaxFileSize = maxFileSize; } /** * Sets the maximum recording duration (in ms) for the next recording session * Setting it to zero (the default) disables the limit. */ public synchronized void setMaxDuration(int maxDurationMs) { switch (mState) { case STATE_RECORD: throw new RuntimeException("setMaxDuration cannot be called while recording!"); case STATE_RELEASED: throw new RuntimeException( "setMaxDuration called on an already released recorder!"); default: break; } mMaxDurationMs = maxDurationMs; } public void setCaptureRate(double fps) { switch (mState) { case STATE_RECORD: throw new RuntimeException("setCaptureRate cannot be called while recording!"); case STATE_RELEASED: throw new RuntimeException( "setCaptureRate called on an already released recorder!"); default: break; } if (mLogVerbose) Log.v(TAG, "Setting time lapse capture rate to " + fps + " fps"); mCaptureRate = fps; } public void setPreviewSurfaceTexture(SurfaceTexture previewSurfaceTexture, int previewWidth, int previewHeight) { if (mLogVerbose) Log.v(TAG, "setPreviewSurfaceTexture(" + this + ")"); switch (mState) { case STATE_RECORD: throw new RuntimeException( "setPreviewSurfaceTexture cannot be called while recording!"); case STATE_RELEASED: throw new RuntimeException( "setPreviewSurfaceTexture called on an already released recorder!"); default: break; } mPreviewSurfaceTexture = previewSurfaceTexture; mPreviewWidth = previewWidth; mPreviewHeight = previewHeight; switch (mState) { case STATE_WAITING_FOR_SURFACE: startPreview(); break; case STATE_STARTING_PREVIEW: case STATE_PREVIEW: initializeEffect(true); break; } } public void setEffect(int effect, Object effectParameter) { if (mLogVerbose) Log.v(TAG, "setEffect: effect ID " + effect + ", parameter " + effectParameter.toString()); switch (mState) { case STATE_RECORD: throw new RuntimeException("setEffect cannot be called while recording!"); case STATE_RELEASED: throw new RuntimeException("setEffect called on an already released recorder!"); default: break; } mEffect = effect; mEffectParameter = effectParameter; if (mState == STATE_PREVIEW || mState == STATE_STARTING_PREVIEW) { initializeEffect(false); } } public interface EffectsListener { public void onEffectsUpdate(int effectId, int effectMsg); public void onEffectsError(Exception exception, String filePath); } public void setEffectsListener(EffectsListener listener) { mEffectsListener = listener; } private void setFaceDetectOrientation() { if (mCurrentEffect == EFFECT_GOOFY_FACE) { Object rotateFilter = getGraphFilter(mRunner, "rotate"); Object metaRotateFilter = getGraphFilter(mRunner, "metarotate"); setInputValue(rotateFilter, "rotation", mOrientationHint); int reverseDegrees = (360 - mOrientationHint) % 360; setInputValue(metaRotateFilter, "rotation", reverseDegrees); } } private void setRecordingOrientation() { if (mState != STATE_RECORD && mRunner != null) { Object bl = newInstance(sCtPoint, new Object[] {0, 0}); Object br = newInstance(sCtPoint, new Object[] {1, 0}); Object tl = newInstance(sCtPoint, new Object[] {0, 1}); Object tr = newInstance(sCtPoint, new Object[] {1, 1}); Object recordingRegion; if (mCameraFacing == Camera.CameraInfo.CAMERA_FACING_BACK) { // The back camera is not mirrored, so use a identity transform recordingRegion = newInstance(sCtQuad, new Object[] {bl, br, tl, tr}); } else { // Recording region needs to be tweaked for front cameras, since they // mirror their preview if (mOrientationHint == 0 || mOrientationHint == 180) { // Horizontal flip in landscape recordingRegion = newInstance(sCtQuad, new Object[] {br, bl, tr, tl}); } else { // Horizontal flip in portrait recordingRegion = newInstance(sCtQuad, new Object[] {tl, tr, bl, br}); } } Object recorder = getGraphFilter(mRunner, "recorder"); setInputValue(recorder, "inputRegion", recordingRegion); } } public void setOrientationHint(int degrees) { switch (mState) { case STATE_RELEASED: throw new RuntimeException( "setOrientationHint called on an already released recorder!"); default: break; } if (mLogVerbose) Log.v(TAG, "Setting orientation hint to: " + degrees); mOrientationHint = degrees; setFaceDetectOrientation(); setRecordingOrientation(); } public void setCameraDisplayOrientation(int orientation) { if (mState != STATE_CONFIGURE) { throw new RuntimeException( "setCameraDisplayOrientation called after configuration!"); } mCameraDisplayOrientation = orientation; } public void setCameraFacing(int facing) { switch (mState) { case STATE_RELEASED: throw new RuntimeException( "setCameraFacing called on alrady released recorder!"); default: break; } mCameraFacing = facing; setRecordingOrientation(); } public void setOnInfoListener(MediaRecorder.OnInfoListener infoListener) { switch (mState) { case STATE_RECORD: throw new RuntimeException("setInfoListener cannot be called while recording!"); case STATE_RELEASED: throw new RuntimeException( "setInfoListener called on an already released recorder!"); default: break; } mInfoListener = infoListener; } public void setOnErrorListener(MediaRecorder.OnErrorListener errorListener) { switch (mState) { case STATE_RECORD: throw new RuntimeException("setErrorListener cannot be called while recording!"); case STATE_RELEASED: throw new RuntimeException( "setErrorListener called on an already released recorder!"); default: break; } mErrorListener = errorListener; } private void initializeFilterFramework() { mGraphEnv = newInstance(sCtGraphEnvironment); invoke(mGraphEnv, sGraphEnvironmentCreateGLEnvironment); int videoFrameWidth = mProfile.videoFrameWidth; int videoFrameHeight = mProfile.videoFrameHeight; if (mCameraDisplayOrientation == 90 || mCameraDisplayOrientation == 270) { int tmp = videoFrameWidth; videoFrameWidth = videoFrameHeight; videoFrameHeight = tmp; } invoke(mGraphEnv, sGraphEnvironmentAddReferences, new Object[] {new Object[] { "textureSourceCallback", mSourceReadyCallback, "recordingWidth", videoFrameWidth, "recordingHeight", videoFrameHeight, "recordingProfile", mProfile, "learningDoneListener", mLearningDoneListener, "recordingDoneListener", mRecordingDoneListener}}); mRunner = null; mGraphId = -1; mCurrentEffect = EFFECT_NONE; } private synchronized void initializeEffect(boolean forceReset) { if (forceReset || mCurrentEffect != mEffect || mCurrentEffect == EFFECT_BACKDROPPER) { invoke(mGraphEnv, sGraphEnvironmentAddReferences, new Object[] {new Object[] { "previewSurfaceTexture", mPreviewSurfaceTexture, "previewWidth", mPreviewWidth, "previewHeight", mPreviewHeight, "orientation", mOrientationHint}}); if (mState == STATE_PREVIEW || mState == STATE_STARTING_PREVIEW) { // Switching effects while running. Inform video camera. sendMessage(mCurrentEffect, EFFECT_MSG_SWITCHING_EFFECT); } switch (mEffect) { case EFFECT_GOOFY_FACE: mGraphId = (Integer) invoke(mGraphEnv, sGraphEnvironmentLoadGraph, new Object[] {mContext, R.raw.goofy_face}); break; case EFFECT_BACKDROPPER: sendMessage(EFFECT_BACKDROPPER, EFFECT_MSG_STARTED_LEARNING); mGraphId = (Integer) invoke(mGraphEnv, sGraphEnvironmentLoadGraph, new Object[] {mContext, R.raw.backdropper}); break; default: throw new RuntimeException("Unknown effect ID" + mEffect + "!"); } mCurrentEffect = mEffect; mOldRunner = mRunner; mRunner = invoke(mGraphEnv, sGraphEnvironmentGetRunner, new Object[] {mGraphId, getConstant(sClsGraphEnvironment, "MODE_ASYNCHRONOUS")}); invoke(mRunner, sGraphRunnerSetDoneCallback, new Object[] {mRunnerDoneCallback}); if (mLogVerbose) { Log.v(TAG, "New runner: " + mRunner + ". Old runner: " + mOldRunner); } if (mState == STATE_PREVIEW || mState == STATE_STARTING_PREVIEW) { // Switching effects while running. Stop existing runner. // The stop callback will take care of starting new runner. mCameraDevice.stopPreview(); mCameraDevice.setPreviewTextureAsync(null); invoke(mOldRunner, sGraphRunnerStop); } } switch (mCurrentEffect) { case EFFECT_GOOFY_FACE: tryEnableVideoStabilization(true); Object goofyFilter = getGraphFilter(mRunner, "goofyrenderer"); setInputValue(goofyFilter, "currentEffect", ((Integer) mEffectParameter).intValue()); break; case EFFECT_BACKDROPPER: tryEnableVideoStabilization(false); Object backgroundSrc = getGraphFilter(mRunner, "background"); if (ApiHelper.HAS_EFFECTS_RECORDING_CONTEXT_INPUT) { // Set the context first before setting sourceUrl to // guarantee the content URI get resolved properly. setInputValue(backgroundSrc, "context", mContext); } setInputValue(backgroundSrc, "sourceUrl", mEffectParameter); // For front camera, the background video needs to be mirrored in the // backdropper filter if (mCameraFacing == Camera.CameraInfo.CAMERA_FACING_FRONT) { Object replacer = getGraphFilter(mRunner, "replacer"); setInputValue(replacer, "mirrorBg", true); if (mLogVerbose) Log.v(TAG, "Setting the background to be mirrored"); } break; default: break; } setFaceDetectOrientation(); setRecordingOrientation(); } public synchronized void startPreview() { if (mLogVerbose) Log.v(TAG, "Starting preview (" + this + ")"); switch (mState) { case STATE_STARTING_PREVIEW: case STATE_PREVIEW: // Already running preview Log.w(TAG, "startPreview called when already running preview"); return; case STATE_RECORD: throw new RuntimeException("Cannot start preview when already recording!"); case STATE_RELEASED: throw new RuntimeException("setEffect called on an already released recorder!"); default: break; } if (mEffect == EFFECT_NONE) { throw new RuntimeException("No effect selected!"); } if (mEffectParameter == null) { throw new RuntimeException("No effect parameter provided!"); } if (mProfile == null) { throw new RuntimeException("No recording profile provided!"); } if (mPreviewSurfaceTexture == null) { if (mLogVerbose) Log.v(TAG, "Passed a null surface; waiting for valid one"); mState = STATE_WAITING_FOR_SURFACE; return; } if (mCameraDevice == null) { throw new RuntimeException("No camera to record from!"); } if (mLogVerbose) Log.v(TAG, "Initializing filter framework and running the graph."); initializeFilterFramework(); initializeEffect(true); mState = STATE_STARTING_PREVIEW; invoke(mRunner, sGraphRunnerRun); // Rest of preview startup handled in mSourceReadyCallback } private Object invokeObjectEquals(Object proxy, Object[] args) { return Boolean.valueOf(proxy == args[0]); } private Object invokeObjectToString() { return "Proxy-" + toString(); } private void invokeOnLearningDone() { if (mLogVerbose) Log.v(TAG, "Learning done callback triggered"); // Called in a processing thread, so have to post message back to UI // thread sendMessage(EFFECT_BACKDROPPER, EFFECT_MSG_DONE_LEARNING); enable3ALocks(true); } private void invokeOnRunnerDone(Object[] args) { int runnerDoneResult = (Integer) args[0]; synchronized (EffectsRecorder.this) { if (mLogVerbose) { Log.v(TAG, "Graph runner done (" + EffectsRecorder.this + ", mRunner " + mRunner + ", mOldRunner " + mOldRunner + ")"); } if (runnerDoneResult == (Integer) getConstant(sClsGraphRunner, "RESULT_ERROR")) { // Handle error case Log.e(TAG, "Error running filter graph!"); Exception e = null; if (mRunner != null) { e = (Exception) invoke(mRunner, sGraphRunnerGetError); } else if (mOldRunner != null) { e = (Exception) invoke(mOldRunner, sGraphRunnerGetError); } raiseError(e); } if (mOldRunner != null) { // Tear down old graph if available if (mLogVerbose) Log.v(TAG, "Tearing down old graph."); Object glEnv = getContextGLEnvironment(mGraphEnv); if (glEnv != null && !(Boolean) invoke(glEnv, sGLEnvironmentIsActive)) { invoke(glEnv, sGLEnvironmentActivate); } getGraphTearDown(mOldRunner, invoke(mGraphEnv, sGraphEnvironmentGetContext)); if (glEnv != null && (Boolean) invoke(glEnv, sGLEnvironmentIsActive)) { invoke(glEnv, sGLEnvironmentDeactivate); } mOldRunner = null; } if (mState == STATE_PREVIEW || mState == STATE_STARTING_PREVIEW) { // Switching effects, start up the new runner if (mLogVerbose) { Log.v(TAG, "Previous effect halted. Running graph again. state: " + mState); } tryEnable3ALocks(false); // In case of an error, the graph restarts from beginning and in case // of the BACKDROPPER effect, the learner re-learns the background. // Hence, we need to show the learning dialogue to the user // to avoid recording before the learning is done. Else, the user // could start recording before the learning is done and the new // background comes up later leading to an end result video // with a heterogeneous background. // For BACKDROPPER effect, this path is also executed sometimes at // the end of a normal recording session. In such a case, the graph // does not restart and hence the learner does not re-learn. So we // do not want to show the learning dialogue then. if (runnerDoneResult == (Integer) getConstant( sClsGraphRunner, "RESULT_ERROR") && mCurrentEffect == EFFECT_BACKDROPPER) { sendMessage(EFFECT_BACKDROPPER, EFFECT_MSG_STARTED_LEARNING); } invoke(mRunner, sGraphRunnerRun); } else if (mState != STATE_RELEASED) { // Shutting down effects if (mLogVerbose) Log.v(TAG, "Runner halted, restoring direct preview"); tryEnable3ALocks(false); sendMessage(EFFECT_NONE, EFFECT_MSG_EFFECTS_STOPPED); } else { // STATE_RELEASED - camera will be/has been released as well, do nothing. } } } private void invokeOnSurfaceTextureSourceReady(Object[] args) { SurfaceTexture source = (SurfaceTexture) args[0]; if (mLogVerbose) Log.v(TAG, "SurfaceTexture ready callback received"); synchronized (EffectsRecorder.this) { mTextureSource = source; if (mState == STATE_CONFIGURE) { // Stop preview happened while the runner was doing startup tasks // Since we haven't started anything up, don't do anything // Rest of cleanup will happen in onRunnerDone if (mLogVerbose) Log.v(TAG, "Ready callback: Already stopped, skipping."); return; } if (mState == STATE_RELEASED) { // EffectsRecorder has been released, so don't touch the camera device // or anything else if (mLogVerbose) Log.v(TAG, "Ready callback: Already released, skipping."); return; } if (source == null) { if (mLogVerbose) { Log.v(TAG, "Ready callback: source null! Looks like graph was closed!"); } if (mState == STATE_PREVIEW || mState == STATE_STARTING_PREVIEW || mState == STATE_RECORD) { // A null source here means the graph is shutting down // unexpectedly, so we need to turn off preview before // the surface texture goes away. if (mLogVerbose) { Log.v(TAG, "Ready callback: State: " + mState + ". stopCameraPreview"); } stopCameraPreview(); } return; } // Lock AE/AWB to reduce transition flicker tryEnable3ALocks(true); mCameraDevice.stopPreview(); if (mLogVerbose) Log.v(TAG, "Runner active, connecting effects preview"); mCameraDevice.setPreviewTextureAsync(mTextureSource); mCameraDevice.startPreviewAsync(); // Unlock AE/AWB after preview started tryEnable3ALocks(false); mState = STATE_PREVIEW; if (mLogVerbose) Log.v(TAG, "Start preview/effect switch complete"); // Sending a message to listener that preview is complete sendMessage(mCurrentEffect, EFFECT_MSG_PREVIEW_RUNNING); } } private void invokeOnRecordingDone() { // Forward the callback to the VideoModule object (as an asynchronous event). if (mLogVerbose) Log.v(TAG, "Recording done callback triggered"); sendMessage(EFFECT_NONE, EFFECT_MSG_RECORDING_DONE); } public synchronized void startRecording() { if (mLogVerbose) Log.v(TAG, "Starting recording (" + this + ")"); switch (mState) { case STATE_RECORD: throw new RuntimeException("Already recording, cannot begin anew!"); case STATE_RELEASED: throw new RuntimeException( "startRecording called on an already released recorder!"); default: break; } if ((mOutputFile == null) && (mFd == null)) { throw new RuntimeException("No output file name or descriptor provided!"); } if (mState == STATE_CONFIGURE) { startPreview(); } Object recorder = getGraphFilter(mRunner, "recorder"); if (mFd != null) { setInputValue(recorder, "outputFileDescriptor", mFd); } else { setInputValue(recorder, "outputFile", mOutputFile); } // It is ok to set the audiosource without checking for timelapse here // since that check will be done in the MediaEncoderFilter itself setInputValue(recorder, "audioSource", MediaRecorder.AudioSource.CAMCORDER); setInputValue(recorder, "recordingProfile", mProfile); setInputValue(recorder, "orientationHint", mOrientationHint); // Important to set the timelapseinterval to 0 if the capture rate is not >0 // since the recorder does not get created every time the recording starts. // The recorder infers whether the capture is timelapsed based on the value of // this interval boolean captureTimeLapse = mCaptureRate > 0; if (captureTimeLapse) { double timeBetweenFrameCapture = 1 / mCaptureRate; setInputValue(recorder, "timelapseRecordingIntervalUs", (long) (1000000 * timeBetweenFrameCapture)); } else { setInputValue(recorder, "timelapseRecordingIntervalUs", 0L); } if (mInfoListener != null) { setInputValue(recorder, "infoListener", mInfoListener); } if (mErrorListener != null) { setInputValue(recorder, "errorListener", mErrorListener); } setInputValue(recorder, "maxFileSize", mMaxFileSize); setInputValue(recorder, "maxDurationMs", mMaxDurationMs); setInputValue(recorder, "recording", true); mSoundPlayer.play(SoundClips.START_VIDEO_RECORDING); mState = STATE_RECORD; } public synchronized void stopRecording() { if (mLogVerbose) Log.v(TAG, "Stop recording (" + this + ")"); switch (mState) { case STATE_CONFIGURE: case STATE_STARTING_PREVIEW: case STATE_PREVIEW: Log.w(TAG, "StopRecording called when recording not active!"); return; case STATE_RELEASED: throw new RuntimeException("stopRecording called on released EffectsRecorder!"); default: break; } Object recorder = getGraphFilter(mRunner, "recorder"); setInputValue(recorder, "recording", false); mSoundPlayer.play(SoundClips.STOP_VIDEO_RECORDING); mState = STATE_PREVIEW; } // Called to tell the filter graph that the display surfacetexture is not valid anymore. // So the filter graph should not hold any reference to the surface created with that. public synchronized void disconnectDisplay() { if (mLogVerbose) Log.v(TAG, "Disconnecting the graph from the " + "SurfaceTexture"); Object display = getGraphFilter(mRunner, "display"); invoke(display, sSurfaceTextureTargetDisconnect, new Object[] { invoke(mGraphEnv, sGraphEnvironmentGetContext)}); } // The VideoModule will call this to notify that the camera is being // released to the outside world. This call should happen after the // stopRecording call. Else, the effects may throw an exception. // With the recording stopped, the stopPreview call will not try to // release the camera again. // This must be called in onPause() if the effects are ON. public synchronized void disconnectCamera() { if (mLogVerbose) Log.v(TAG, "Disconnecting the effects from Camera"); stopCameraPreview(); mCameraDevice = null; } // In a normal case, when the disconnect is not called, we should not // set the camera device to null, since on return callback, we try to // enable 3A locks, which need the cameradevice. public synchronized void stopCameraPreview() { if (mLogVerbose) Log.v(TAG, "Stopping camera preview."); if (mCameraDevice == null) { Log.d(TAG, "Camera already null. Nothing to disconnect"); return; } mCameraDevice.stopPreview(); mCameraDevice.setPreviewTextureAsync(null); } // Stop and release effect resources public synchronized void stopPreview() { if (mLogVerbose) Log.v(TAG, "Stopping preview (" + this + ")"); switch (mState) { case STATE_CONFIGURE: Log.w(TAG, "StopPreview called when preview not active!"); return; case STATE_RELEASED: throw new RuntimeException("stopPreview called on released EffectsRecorder!"); default: break; } if (mState == STATE_RECORD) { stopRecording(); } mCurrentEffect = EFFECT_NONE; // This will not do anything if the camera has already been disconnected. stopCameraPreview(); mState = STATE_CONFIGURE; mOldRunner = mRunner; invoke(mRunner, sGraphRunnerStop); mRunner = null; // Rest of stop and release handled in mRunnerDoneCallback } // Try to enable/disable video stabilization if supported; otherwise return false // It is called from a synchronized block. boolean tryEnableVideoStabilization(boolean toggle) { if (mLogVerbose) Log.v(TAG, "tryEnableVideoStabilization."); if (mCameraDevice == null) { Log.d(TAG, "Camera already null. Not enabling video stabilization."); return false; } Camera.Parameters params = mCameraDevice.getParameters(); String vstabSupported = params.get("video-stabilization-supported"); if ("true".equals(vstabSupported)) { if (mLogVerbose) Log.v(TAG, "Setting video stabilization to " + toggle); params.set("video-stabilization", toggle ? "true" : "false"); mCameraDevice.setParameters(params); return true; } if (mLogVerbose) Log.v(TAG, "Video stabilization not supported"); return false; } // Try to enable/disable 3A locks if supported; otherwise return false @TargetApi(ApiHelper.VERSION_CODES.ICE_CREAM_SANDWICH) synchronized boolean tryEnable3ALocks(boolean toggle) { if (mLogVerbose) Log.v(TAG, "tryEnable3ALocks"); if (mCameraDevice == null) { Log.d(TAG, "Camera already null. Not tryenabling 3A locks."); return false; } Camera.Parameters params = mCameraDevice.getParameters(); if (Util.isAutoExposureLockSupported(params) && Util.isAutoWhiteBalanceLockSupported(params)) { params.setAutoExposureLock(toggle); params.setAutoWhiteBalanceLock(toggle); mCameraDevice.setParameters(params); return true; } return false; } // Try to enable/disable 3A locks if supported; otherwise, throw error // Use this when locks are essential to success synchronized void enable3ALocks(boolean toggle) { if (mLogVerbose) Log.v(TAG, "Enable3ALocks"); if (mCameraDevice == null) { Log.d(TAG, "Camera already null. Not enabling 3A locks."); return; } Camera.Parameters params = mCameraDevice.getParameters(); if (!tryEnable3ALocks(toggle)) { throw new RuntimeException("Attempt to lock 3A on camera with no locking support!"); } } static class SerializableInvocationHandler implements InvocationHandler, Serializable { private final int mEffectsRecorderIndex; public SerializableInvocationHandler(int index) { mEffectsRecorderIndex = index; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (sEffectsRecorder == null) return null; if (mEffectsRecorderIndex != sEffectsRecorderIndex) { Log.v(TAG, "Ignore old callback " + mEffectsRecorderIndex); return null; } if (method.equals(sObjectEquals)) { return sEffectsRecorder.invokeObjectEquals(proxy, args); } else if (method.equals(sObjectToString)) { return sEffectsRecorder.invokeObjectToString(); } else if (method.equals(sLearningDoneListenerOnLearningDone)) { sEffectsRecorder.invokeOnLearningDone(); } else if (method.equals(sOnRunnerDoneListenerOnRunnerDone)) { sEffectsRecorder.invokeOnRunnerDone(args); } else if (method.equals( sSurfaceTextureSourceListenerOnSurfaceTextureSourceReady)) { sEffectsRecorder.invokeOnSurfaceTextureSourceReady(args); } else if (method.equals(sOnRecordingDoneListenerOnRecordingDone)) { sEffectsRecorder.invokeOnRecordingDone(); } return null; } } // Indicates that all camera/recording activity needs to halt public synchronized void release() { if (mLogVerbose) Log.v(TAG, "Releasing (" + this + ")"); switch (mState) { case STATE_RECORD: case STATE_STARTING_PREVIEW: case STATE_PREVIEW: stopPreview(); // Fall-through default: if (mSoundPlayer != null) { mSoundPlayer.release(); mSoundPlayer = null; } mState = STATE_RELEASED; break; } sEffectsRecorder = null; } private void sendMessage(final int effect, final int msg) { if (mEffectsListener != null) { mHandler.post(new Runnable() { @Override public void run() { mEffectsListener.onEffectsUpdate(effect, msg); } }); } } private void raiseError(final Exception exception) { if (mEffectsListener != null) { mHandler.post(new Runnable() { @Override public void run() { if (mFd != null) { mEffectsListener.onEffectsError(exception, null); } else { mEffectsListener.onEffectsError(exception, mOutputFile); } } }); } } // invoke method on receiver with no arguments private Object invoke(Object receiver, Method method) { try { return method.invoke(receiver); } catch (Exception ex) { throw new RuntimeException(ex); } } // invoke method on receiver with arguments private Object invoke(Object receiver, Method method, Object[] args) { try { return method.invoke(receiver, args); } catch (Exception ex) { throw new RuntimeException(ex); } } private void setInputValue(Object receiver, String key, Object value) { try { sFilterSetInputValue.invoke(receiver, new Object[] {key, value}); } catch (Exception ex) { throw new RuntimeException(ex); } } private Object newInstance(Constructor ct, Object[] initArgs) { try { return ct.newInstance(initArgs); } catch (Exception ex) { throw new RuntimeException(ex); } } private Object newInstance(Constructor ct) { try { return ct.newInstance(); } catch (Exception ex) { throw new RuntimeException(ex); } } private Object getGraphFilter(Object receiver, String name) { try { return sFilterGraphGetFilter.invoke(sGraphRunnerGetGraph .invoke(receiver), new Object[] {name}); } catch (Exception ex) { throw new RuntimeException(ex); } } private Object getContextGLEnvironment(Object receiver) { try { return sFilterContextGetGLEnvironment .invoke(sGraphEnvironmentGetContext.invoke(receiver)); } catch (Exception ex) { throw new RuntimeException(ex); } } private void getGraphTearDown(Object receiver, Object filterContext) { try { sFilterGraphTearDown.invoke(sGraphRunnerGetGraph.invoke(receiver), new Object[]{filterContext}); } catch (Exception ex) { throw new RuntimeException(ex); } } private Object getConstant(Class cls, String name) { try { return cls.getDeclaredField(name).get(null); } catch (Exception ex) { throw new RuntimeException(ex); } } }