| /* |
| * 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.content.Context; |
| import android.content.res.AssetFileDescriptor; |
| import android.filterfw.GraphEnvironment; |
| import android.filterfw.core.Filter; |
| import android.filterfw.core.GLEnvironment; |
| import android.filterfw.core.GraphRunner; |
| import android.filterfw.core.GraphRunner.OnRunnerDoneListener; |
| import android.filterfw.geometry.Point; |
| import android.filterfw.geometry.Quad; |
| import android.filterpacks.videoproc.BackDropperFilter; |
| import android.filterpacks.videoproc.BackDropperFilter.LearningDoneListener; |
| import android.filterpacks.videosink.MediaEncoderFilter.OnRecordingDoneListener; |
| import android.filterpacks.videosrc.SurfaceTextureSource.SurfaceTextureSourceListener; |
| |
| import android.graphics.SurfaceTexture; |
| import android.hardware.Camera; |
| import android.media.MediaActionSound; |
| import android.media.MediaRecorder; |
| import android.media.CamcorderProfile; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.ParcelFileDescriptor; |
| import android.util.Log; |
| import android.view.Surface; |
| import android.view.SurfaceHolder; |
| |
| import java.io.IOException; |
| import java.io.FileNotFoundException; |
| import java.io.File; |
| import java.lang.Runnable; |
| import java.io.FileDescriptor; |
| |
| |
| /** |
| * Encapsulates the mobile filter framework components needed to record video with |
| * effects applied. Modeled after MediaRecorder. |
| */ |
| public class EffectsRecorder { |
| |
| 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 boolean mReleased; |
| |
| private Camera mCameraDevice; |
| private CamcorderProfile mProfile; |
| private double mCaptureRate = 0; |
| private SurfaceHolder mPreviewSurfaceHolder; |
| 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 boolean mAppIsLandscape; |
| |
| private int mEffect = EFFECT_NONE; |
| private int mCurrentEffect = EFFECT_NONE; |
| private EffectsListener mEffectsListener; |
| |
| private Object mEffectParameter; |
| |
| private GraphEnvironment mGraphEnv; |
| private int mGraphId; |
| private GraphRunner mRunner = null; |
| private GraphRunner 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 static final String TAG = "effectsrecorder"; |
| private MediaActionSound mCameraSound; |
| |
| /** Determine if a given effect is supported at runtime |
| * Some effects require libraries not available on all devices |
| */ |
| public static boolean isEffectSupported(int effectId) { |
| switch (effectId) { |
| case EFFECT_GOOFY_FACE: |
| return Filter.isAvailable("com.google.android.filterpacks.facedetect.GoofyRenderFilter"); |
| case EFFECT_BACKDROPPER: |
| return Filter.isAvailable("android.filterpacks.videoproc.BackDropperFilter"); |
| default: |
| return false; |
| } |
| } |
| |
| public EffectsRecorder(Context context) { |
| if (mLogVerbose) Log.v(TAG, "EffectsRecorder created (" + this + ")"); |
| mContext = context; |
| mHandler = new Handler(Looper.getMainLooper()); |
| mCameraSound = new MediaActionSound(); |
| } |
| |
| public void setCamera(Camera 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 setPreviewDisplay(SurfaceHolder previewSurfaceHolder, |
| int previewWidth, |
| int previewHeight) { |
| if (mLogVerbose) Log.v(TAG, "setPreviewDisplay (" + this + ")"); |
| switch (mState) { |
| case STATE_RECORD: |
| throw new RuntimeException("setPreviewDisplay cannot be called while recording!"); |
| case STATE_RELEASED: |
| throw new RuntimeException("setPreviewDisplay called on an already released recorder!"); |
| default: |
| break; |
| } |
| |
| mPreviewSurfaceHolder = previewSurfaceHolder; |
| 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) { |
| Filter rotateFilter = mRunner.getGraph().getFilter("rotate"); |
| Filter metaRotateFilter = mRunner.getGraph().getFilter("metarotate"); |
| rotateFilter.setInputValue("rotation", mOrientationHint); |
| int reverseDegrees = (360 - mOrientationHint) % 360; |
| metaRotateFilter.setInputValue("rotation", reverseDegrees); |
| } |
| } |
| |
| private void setRecordingOrientation() { |
| if ( mState != STATE_RECORD && mRunner != null) { |
| Point bl = new Point(0, 0); |
| Point br = new Point(1, 0); |
| Point tl = new Point(0, 1); |
| Point tr = new Point(1, 1); |
| Quad recordingRegion; |
| if (mCameraFacing == Camera.CameraInfo.CAMERA_FACING_BACK) { |
| // The back camera is not mirrored, so use a identity transform |
| recordingRegion = new Quad(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 = new Quad(br, bl, tr, tl); |
| } else { |
| // Horizontal flip in portrait |
| recordingRegion = new Quad(tl, tr, bl, br); |
| } |
| } |
| Filter recorder = mRunner.getGraph().getFilter("recorder"); |
| recorder.setInputValue("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(); |
| } |
| |
| /** Passes the native orientation of the Camera app (device dependent) |
| * to allow for correct output aspect ratio. Defaults to portrait */ |
| public void setAppToLandscape(boolean landscape) { |
| if (mState != STATE_CONFIGURE) { |
| throw new RuntimeException( |
| "setAppToLandscape called after configuration!"); |
| } |
| mAppIsLandscape = landscape; |
| } |
| |
| 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 = new GraphEnvironment(); |
| mGraphEnv.createGLEnvironment(); |
| |
| if (mLogVerbose) { |
| Log.v(TAG, "Effects framework initializing. Recording size " |
| + mProfile.videoFrameWidth + ", " + mProfile.videoFrameHeight); |
| } |
| if (!mAppIsLandscape) { |
| int tmp; |
| tmp = mProfile.videoFrameWidth; |
| mProfile.videoFrameWidth = mProfile.videoFrameHeight; |
| mProfile.videoFrameHeight = tmp; |
| } |
| mGraphEnv.addReferences( |
| "textureSourceCallback", mSourceReadyCallback, |
| "recordingWidth", mProfile.videoFrameWidth, |
| "recordingHeight", mProfile.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) { |
| if (mLogVerbose) { |
| Log.v(TAG, "Effect initializing. Preview size " |
| + mPreviewWidth + ", " + mPreviewHeight); |
| } |
| |
| mGraphEnv.addReferences( |
| "previewSurface", mPreviewSurfaceHolder.getSurface(), |
| "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 = mGraphEnv.loadGraph(mContext, R.raw.goofy_face); |
| break; |
| case EFFECT_BACKDROPPER: |
| sendMessage(EFFECT_BACKDROPPER, EFFECT_MSG_STARTED_LEARNING); |
| mGraphId = mGraphEnv.loadGraph(mContext, R.raw.backdropper); |
| break; |
| default: |
| throw new RuntimeException("Unknown effect ID" + mEffect + "!"); |
| } |
| mCurrentEffect = mEffect; |
| |
| mOldRunner = mRunner; |
| mRunner = mGraphEnv.getRunner(mGraphId, GraphEnvironment.MODE_ASYNCHRONOUS); |
| mRunner.setDoneCallback(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(); |
| try { |
| mCameraDevice.setPreviewTexture(null); |
| } catch(IOException e) { |
| throw new RuntimeException("Unable to connect camera to effect input", e); |
| } |
| mOldRunner.stop(); |
| } |
| } |
| |
| switch (mCurrentEffect) { |
| case EFFECT_GOOFY_FACE: |
| tryEnableVideoStabilization(true); |
| Filter goofyFilter = mRunner.getGraph().getFilter("goofyrenderer"); |
| goofyFilter.setInputValue("currentEffect", |
| ((Integer)mEffectParameter).intValue()); |
| break; |
| case EFFECT_BACKDROPPER: |
| tryEnableVideoStabilization(false); |
| Filter backgroundSrc = mRunner.getGraph().getFilter("background"); |
| backgroundSrc.setInputValue("sourceUrl", |
| (String)mEffectParameter); |
| // For front camera, the background video needs to be mirrored in the |
| // backdropper filter |
| if (mCameraFacing == Camera.CameraInfo.CAMERA_FACING_FRONT) { |
| Filter replacer = mRunner.getGraph().getFilter("replacer"); |
| replacer.setInputValue("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 (mPreviewSurfaceHolder == null) { |
| if (mLogVerbose) Log.v(TAG, "Passed a null surface holder; 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 graph"); |
| |
| initializeFilterFramework(); |
| |
| initializeEffect(true); |
| |
| if (mLogVerbose) Log.v(TAG, "Starting filter graph"); |
| |
| mState = STATE_STARTING_PREVIEW; |
| mRunner.run(); |
| // Rest of preview startup handled in mSourceReadyCallback |
| } |
| |
| private SurfaceTextureSourceListener mSourceReadyCallback = |
| new SurfaceTextureSourceListener() { |
| public void onSurfaceTextureSourceReady(SurfaceTexture source) { |
| 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 (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. |
| mCameraDevice.stopPreview(); |
| try { |
| mCameraDevice.setPreviewTexture(null); |
| } catch(IOException e) { |
| throw new RuntimeException("Unable to disconnect " + |
| "camera from effect input", e); |
| } |
| } |
| return; |
| } |
| |
| // Lock AE/AWB to reduce transition flicker |
| tryEnable3ALocks(true); |
| |
| mCameraDevice.stopPreview(); |
| if (mLogVerbose) Log.v(TAG, "Runner active, connecting effects preview"); |
| try { |
| mCameraDevice.setPreviewTexture(mTextureSource); |
| } catch(IOException e) { |
| throw new RuntimeException("Unable to connect camera to effect input", e); |
| } |
| |
| mCameraDevice.startPreview(); |
| |
| // 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 LearningDoneListener mLearningDoneListener = |
| new LearningDoneListener() { |
| public void onLearningDone(BackDropperFilter filter) { |
| 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); |
| } |
| }; |
| |
| // A callback to finalize the media after the recording is done. |
| private OnRecordingDoneListener mRecordingDoneListener = |
| new OnRecordingDoneListener() { |
| // Forward the callback to the VideoCamera object (as an asynchronous event). |
| public void onRecordingDone() { |
| 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(); |
| } |
| |
| Filter recorder = mRunner.getGraph().getFilter("recorder"); |
| if (mFd != null) { |
| recorder.setInputValue("outputFileDescriptor", mFd); |
| } else { |
| recorder.setInputValue("outputFile", mOutputFile); |
| } |
| // It is ok to set the audiosource without checking for timelapse here |
| // since that check will be done in the MediaEncoderFilter itself |
| recorder.setInputValue("audioSource", MediaRecorder.AudioSource.CAMCORDER); |
| |
| recorder.setInputValue("recordingProfile", mProfile); |
| recorder.setInputValue("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; |
| recorder.setInputValue("timelapseRecordingIntervalUs", |
| (long) (1000000 * timeBetweenFrameCapture)); |
| } else { |
| recorder.setInputValue("timelapseRecordingIntervalUs", 0L); |
| } |
| |
| if (mInfoListener != null) { |
| recorder.setInputValue("infoListener", mInfoListener); |
| } |
| if (mErrorListener != null) { |
| recorder.setInputValue("errorListener", mErrorListener); |
| } |
| recorder.setInputValue("maxFileSize", mMaxFileSize); |
| recorder.setInputValue("maxDurationMs", mMaxDurationMs); |
| recorder.setInputValue("recording", true); |
| mCameraSound.play(MediaActionSound.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; |
| } |
| Filter recorder = mRunner.getGraph().getFilter("recorder"); |
| recorder.setInputValue("recording", false); |
| mCameraSound.play(MediaActionSound.STOP_VIDEO_RECORDING); |
| mState = STATE_PREVIEW; |
| } |
| |
| // 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; |
| |
| mCameraDevice.stopPreview(); |
| try { |
| mCameraDevice.setPreviewTexture(null); |
| } catch(IOException e) { |
| throw new RuntimeException("Unable to connect camera to effect input", e); |
| } |
| mCameraSound.release(); |
| |
| mState = STATE_CONFIGURE; |
| mOldRunner = mRunner; |
| mRunner.stop(); |
| mRunner = null; |
| // Rest of stop and release handled in mRunnerDoneCallback |
| } |
| |
| // Try to enable/disable video stabilization if supported; otherwise return false |
| boolean tryEnableVideoStabilization(boolean toggle) { |
| 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 |
| boolean tryEnable3ALocks(boolean toggle) { |
| Camera.Parameters params = mCameraDevice.getParameters(); |
| if (params.isAutoExposureLockSupported() && |
| params.isAutoWhiteBalanceLockSupported() ) { |
| 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 |
| void enable3ALocks(boolean toggle) { |
| Camera.Parameters params = mCameraDevice.getParameters(); |
| if (!tryEnable3ALocks(toggle)) { |
| throw new RuntimeException("Attempt to lock 3A on camera with no locking support!"); |
| } |
| } |
| |
| private OnRunnerDoneListener mRunnerDoneCallback = |
| new OnRunnerDoneListener() { |
| public void onRunnerDone(int result) { |
| synchronized(EffectsRecorder.this) { |
| if (mLogVerbose) { |
| Log.v(TAG, |
| "Graph runner done (" + EffectsRecorder.this |
| + ", mRunner " + mRunner |
| + ", mOldRunner " + mOldRunner + ")"); |
| } |
| if (result == GraphRunner.RESULT_ERROR) { |
| // Handle error case |
| Log.e(TAG, "Error running filter graph!"); |
| Exception e = null; |
| if (mRunner != null) { |
| e = mRunner.getError(); |
| } else if (mOldRunner != null) { |
| e = mOldRunner.getError(); |
| } |
| raiseError(e); |
| } |
| if (mOldRunner != null) { |
| // Tear down old graph if available |
| if (mLogVerbose) Log.v(TAG, "Tearing down old graph."); |
| GLEnvironment glEnv = mGraphEnv.getContext().getGLEnvironment(); |
| if (glEnv != null && !glEnv.isActive()) { |
| glEnv.activate(); |
| } |
| mOldRunner.getGraph().tearDown(mGraphEnv.getContext()); |
| if (glEnv != null && glEnv.isActive()) { |
| glEnv.deactivate(); |
| } |
| 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, starting new effect."); |
| tryEnable3ALocks(false); |
| mRunner.run(); |
| } 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. |
| } |
| } |
| } |
| }; |
| |
| // 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: |
| mState = STATE_RELEASED; |
| break; |
| } |
| } |
| |
| private void sendMessage(final int effect, final int msg) { |
| if (mEffectsListener != null) { |
| mHandler.post(new Runnable() { |
| public void run() { |
| mEffectsListener.onEffectsUpdate(effect, msg); |
| } |
| }); |
| } |
| } |
| |
| private void raiseError(final Exception exception) { |
| if (mEffectsListener != null) { |
| mHandler.post(new Runnable() { |
| public void run() { |
| if (mFd != null) { |
| mEffectsListener.onEffectsError(exception, null); |
| } else { |
| mEffectsListener.onEffectsError(exception, mOutputFile); |
| } |
| } |
| }); |
| } |
| } |
| |
| } |
