| /* |
| * 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 android.filterpacks.videosink; |
| |
| import android.filterfw.core.Filter; |
| import android.filterfw.core.FilterContext; |
| import android.filterfw.core.Frame; |
| import android.filterfw.core.FrameFormat; |
| import android.filterfw.core.GenerateFieldPort; |
| import android.filterfw.core.GLFrame; |
| import android.filterfw.core.MutableFrameFormat; |
| import android.filterfw.core.ShaderProgram; |
| import android.filterfw.format.ImageFormat; |
| import android.filterfw.geometry.Point; |
| import android.filterfw.geometry.Quad; |
| import android.media.MediaRecorder; |
| import android.media.CamcorderProfile; |
| import android.filterfw.core.GLEnvironment; |
| |
| import java.io.IOException; |
| import java.io.FileDescriptor; |
| |
| import android.util.Log; |
| |
| /** @hide */ |
| public class MediaEncoderFilter extends Filter { |
| |
| /** User-visible parameters */ |
| |
| /** Recording state. When set to false, recording will stop, or will not |
| * start if not yet running the graph. Instead, frames are simply ignored. |
| * When switched back to true, recording will restart. This allows a single |
| * graph to both provide preview and to record video. If this is false, |
| * recording settings can be updated while the graph is running. |
| */ |
| @GenerateFieldPort(name = "recording", hasDefault = true) |
| private boolean mRecording = true; |
| |
| /** Filename to save the output. */ |
| @GenerateFieldPort(name = "outputFile", hasDefault = true) |
| private String mOutputFile = new String("/sdcard/MediaEncoderOut.mp4"); |
| |
| /** File Descriptor to save the output. */ |
| @GenerateFieldPort(name = "outputFileDescriptor", hasDefault = true) |
| private FileDescriptor mFd = null; |
| |
| /** Input audio source. If not set, no audio will be recorded. |
| * Select from the values in MediaRecorder.AudioSource |
| */ |
| @GenerateFieldPort(name = "audioSource", hasDefault = true) |
| private int mAudioSource = NO_AUDIO_SOURCE; |
| |
| /** Media recorder info listener, which needs to implement |
| * MediaRecorder.OnInfoListener. Set this to receive notifications about |
| * recording events. |
| */ |
| @GenerateFieldPort(name = "infoListener", hasDefault = true) |
| private MediaRecorder.OnInfoListener mInfoListener = null; |
| |
| /** Media recorder error listener, which needs to implement |
| * MediaRecorder.OnErrorListener. Set this to receive notifications about |
| * recording errors. |
| */ |
| @GenerateFieldPort(name = "errorListener", hasDefault = true) |
| private MediaRecorder.OnErrorListener mErrorListener = null; |
| |
| /** Media recording done callback, which needs to implement OnRecordingDoneListener. |
| * Set this to finalize media upon completion of media recording. |
| */ |
| @GenerateFieldPort(name = "recordingDoneListener", hasDefault = true) |
| private OnRecordingDoneListener mRecordingDoneListener = null; |
| |
| /** Orientation hint. Used for indicating proper video playback orientation. |
| * Units are in degrees of clockwise rotation, valid values are (0, 90, 180, |
| * 270). |
| */ |
| @GenerateFieldPort(name = "orientationHint", hasDefault = true) |
| private int mOrientationHint = 0; |
| |
| /** Camcorder profile to use. Select from the profiles available in |
| * android.media.CamcorderProfile. If this field is set, it overrides |
| * settings to width, height, framerate, outputFormat, and videoEncoder. |
| */ |
| @GenerateFieldPort(name = "recordingProfile", hasDefault = true) |
| private CamcorderProfile mProfile = null; |
| |
| /** Frame width to be encoded, defaults to 320. |
| * Actual received frame size has to match this */ |
| @GenerateFieldPort(name = "width", hasDefault = true) |
| private int mWidth = 0; |
| |
| /** Frame height to to be encoded, defaults to 240. |
| * Actual received frame size has to match */ |
| @GenerateFieldPort(name = "height", hasDefault = true) |
| private int mHeight = 0; |
| |
| /** Stream framerate to encode the frames at. |
| * By default, frames are encoded at 30 FPS*/ |
| @GenerateFieldPort(name = "framerate", hasDefault = true) |
| private int mFps = 30; |
| |
| /** The output format to encode the frames in. |
| * Choose an output format from the options in |
| * android.media.MediaRecorder.OutputFormat */ |
| @GenerateFieldPort(name = "outputFormat", hasDefault = true) |
| private int mOutputFormat = MediaRecorder.OutputFormat.MPEG_4; |
| |
| /** The videoencoder to encode the frames with. |
| * Choose a videoencoder from the options in |
| * android.media.MediaRecorder.VideoEncoder */ |
| @GenerateFieldPort(name = "videoEncoder", hasDefault = true) |
| private int mVideoEncoder = MediaRecorder.VideoEncoder.H264; |
| |
| /** The input region to read from the frame. The corners of this quad are |
| * mapped to the output rectangle. The input frame ranges from (0,0)-(1,1), |
| * top-left to bottom-right. The corners of the quad are specified in the |
| * order bottom-left, bottom-right, top-left, top-right. |
| */ |
| @GenerateFieldPort(name = "inputRegion", hasDefault = true) |
| private Quad mSourceRegion; |
| |
| /** The maximum filesize (in bytes) of the recording session. |
| * By default, it will be 0 and will be passed on to the MediaRecorder. |
| * If the limit is zero or negative, MediaRecorder will disable the limit*/ |
| @GenerateFieldPort(name = "maxFileSize", hasDefault = true) |
| private long mMaxFileSize = 0; |
| |
| /** The maximum duration (in milliseconds) of the recording session. |
| * By default, it will be 0 and will be passed on to the MediaRecorder. |
| * If the limit is zero or negative, MediaRecorder will record indefinitely*/ |
| @GenerateFieldPort(name = "maxDurationMs", hasDefault = true) |
| private int mMaxDurationMs = 0; |
| |
| /** TimeLapse Interval between frames. |
| * By default, it will be 0. Whether the recording is timelapsed |
| * is inferred based on its value being greater than 0 */ |
| @GenerateFieldPort(name = "timelapseRecordingIntervalUs", hasDefault = true) |
| private long mTimeBetweenTimeLapseFrameCaptureUs = 0; |
| |
| // End of user visible parameters |
| |
| private static final int NO_AUDIO_SOURCE = -1; |
| |
| private int mSurfaceId; |
| private ShaderProgram mProgram; |
| private GLFrame mScreen; |
| |
| private boolean mRecordingActive = false; |
| private long mTimestampNs = 0; |
| private long mLastTimeLapseFrameRealTimestampNs = 0; |
| private int mNumFramesEncoded = 0; |
| // Used to indicate whether recording is timelapsed. |
| // Inferred based on (mTimeBetweenTimeLapseFrameCaptureUs > 0) |
| private boolean mCaptureTimeLapse = false; |
| |
| private boolean mLogVerbose; |
| private static final String TAG = "MediaEncoderFilter"; |
| |
| // Our hook to the encoder |
| private MediaRecorder mMediaRecorder; |
| |
| /** Callback to be called when media recording completes. */ |
| |
| public interface OnRecordingDoneListener { |
| public void onRecordingDone(); |
| } |
| |
| public MediaEncoderFilter(String name) { |
| super(name); |
| Point bl = new Point(0, 0); |
| Point br = new Point(1, 0); |
| Point tl = new Point(0, 1); |
| Point tr = new Point(1, 1); |
| mSourceRegion = new Quad(bl, br, tl, tr); |
| mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE); |
| } |
| |
| @Override |
| public void setupPorts() { |
| // Add input port- will accept RGBA GLFrames |
| addMaskedInputPort("videoframe", ImageFormat.create(ImageFormat.COLORSPACE_RGBA, |
| FrameFormat.TARGET_GPU)); |
| } |
| |
| @Override |
| public void fieldPortValueUpdated(String name, FilterContext context) { |
| if (mLogVerbose) Log.v(TAG, "Port " + name + " has been updated"); |
| if (name.equals("recording")) return; |
| if (name.equals("inputRegion")) { |
| if (isOpen()) updateSourceRegion(); |
| return; |
| } |
| // TODO: Not sure if it is possible to update the maxFileSize |
| // when the recording is going on. For now, not doing that. |
| if (isOpen() && mRecordingActive) { |
| throw new RuntimeException("Cannot change recording parameters" |
| + " when the filter is recording!"); |
| } |
| } |
| |
| private void updateSourceRegion() { |
| // Flip source quad to map to OpenGL origin |
| Quad flippedRegion = new Quad(); |
| flippedRegion.p0 = mSourceRegion.p2; |
| flippedRegion.p1 = mSourceRegion.p3; |
| flippedRegion.p2 = mSourceRegion.p0; |
| flippedRegion.p3 = mSourceRegion.p1; |
| mProgram.setSourceRegion(flippedRegion); |
| } |
| |
| // update the MediaRecorderParams based on the variables. |
| // These have to be in certain order as per the MediaRecorder |
| // documentation |
| private void updateMediaRecorderParams() { |
| mCaptureTimeLapse = mTimeBetweenTimeLapseFrameCaptureUs > 0; |
| final int GRALLOC_BUFFER = 2; |
| mMediaRecorder.setVideoSource(GRALLOC_BUFFER); |
| if (!mCaptureTimeLapse && (mAudioSource != NO_AUDIO_SOURCE)) { |
| mMediaRecorder.setAudioSource(mAudioSource); |
| } |
| if (mProfile != null) { |
| mMediaRecorder.setProfile(mProfile); |
| mFps = mProfile.videoFrameRate; |
| // If width and height are set larger than 0, then those |
| // overwrite the ones in the profile. |
| if (mWidth > 0 && mHeight > 0) { |
| mMediaRecorder.setVideoSize(mWidth, mHeight); |
| } |
| } else { |
| mMediaRecorder.setOutputFormat(mOutputFormat); |
| mMediaRecorder.setVideoEncoder(mVideoEncoder); |
| mMediaRecorder.setVideoSize(mWidth, mHeight); |
| mMediaRecorder.setVideoFrameRate(mFps); |
| } |
| mMediaRecorder.setOrientationHint(mOrientationHint); |
| mMediaRecorder.setOnInfoListener(mInfoListener); |
| mMediaRecorder.setOnErrorListener(mErrorListener); |
| if (mFd != null) { |
| mMediaRecorder.setOutputFile(mFd); |
| } else { |
| mMediaRecorder.setOutputFile(mOutputFile); |
| } |
| try { |
| mMediaRecorder.setMaxFileSize(mMaxFileSize); |
| } catch (Exception e) { |
| // Following the logic in VideoCamera.java (in Camera app) |
| // We are going to ignore failure of setMaxFileSize here, as |
| // a) The composer selected may simply not support it, or |
| // b) The underlying media framework may not handle 64-bit range |
| // on the size restriction. |
| Log.w(TAG, "Setting maxFileSize on MediaRecorder unsuccessful! " |
| + e.getMessage()); |
| } |
| mMediaRecorder.setMaxDuration(mMaxDurationMs); |
| } |
| |
| @Override |
| public void prepare(FilterContext context) { |
| if (mLogVerbose) Log.v(TAG, "Preparing"); |
| |
| mProgram = ShaderProgram.createIdentity(context); |
| |
| mRecordingActive = false; |
| } |
| |
| @Override |
| public void open(FilterContext context) { |
| if (mLogVerbose) Log.v(TAG, "Opening"); |
| updateSourceRegion(); |
| if (mRecording) startRecording(context); |
| } |
| |
| private void startRecording(FilterContext context) { |
| if (mLogVerbose) Log.v(TAG, "Starting recording"); |
| |
| // Create a frame representing the screen |
| MutableFrameFormat screenFormat = new MutableFrameFormat( |
| FrameFormat.TYPE_BYTE, FrameFormat.TARGET_GPU); |
| screenFormat.setBytesPerSample(4); |
| |
| int width, height; |
| boolean widthHeightSpecified = mWidth > 0 && mHeight > 0; |
| // If width and height are specified, then use those instead |
| // of that in the profile. |
| if (mProfile != null && !widthHeightSpecified) { |
| width = mProfile.videoFrameWidth; |
| height = mProfile.videoFrameHeight; |
| } else { |
| width = mWidth; |
| height = mHeight; |
| } |
| screenFormat.setDimensions(width, height); |
| mScreen = (GLFrame)context.getFrameManager().newBoundFrame( |
| screenFormat, GLFrame.EXISTING_FBO_BINDING, 0); |
| |
| // Initialize the media recorder |
| |
| mMediaRecorder = new MediaRecorder(); |
| updateMediaRecorderParams(); |
| |
| try { |
| mMediaRecorder.prepare(); |
| } catch (IllegalStateException e) { |
| throw e; |
| } catch (IOException e) { |
| throw new RuntimeException("IOException in" |
| + "MediaRecorder.prepare()!", e); |
| } catch (Exception e) { |
| throw new RuntimeException("Unknown Exception in" |
| + "MediaRecorder.prepare()!", e); |
| } |
| // Make sure start() is called before trying to |
| // register the surface. The native window handle needed to create |
| // the surface is initiated in start() |
| mMediaRecorder.start(); |
| if (mLogVerbose) Log.v(TAG, "Open: registering surface from Mediarecorder"); |
| mSurfaceId = context.getGLEnvironment(). |
| registerSurfaceFromMediaRecorder(mMediaRecorder); |
| mNumFramesEncoded = 0; |
| mRecordingActive = true; |
| } |
| |
| public boolean skipFrameAndModifyTimestamp(long timestampNs) { |
| // first frame- encode. Don't skip |
| if (mNumFramesEncoded == 0) { |
| mLastTimeLapseFrameRealTimestampNs = timestampNs; |
| mTimestampNs = timestampNs; |
| if (mLogVerbose) Log.v(TAG, "timelapse: FIRST frame, last real t= " |
| + mLastTimeLapseFrameRealTimestampNs + |
| ", setting t = " + mTimestampNs ); |
| return false; |
| } |
| |
| // Workaround to bypass the first 2 input frames for skipping. |
| // The first 2 output frames from the encoder are: decoder specific info and |
| // the compressed video frame data for the first input video frame. |
| if (mNumFramesEncoded >= 2 && timestampNs < |
| (mLastTimeLapseFrameRealTimestampNs + 1000L * mTimeBetweenTimeLapseFrameCaptureUs)) { |
| // If 2 frames have been already encoded, |
| // Skip all frames from last encoded frame until |
| // sufficient time (mTimeBetweenTimeLapseFrameCaptureUs) has passed. |
| if (mLogVerbose) Log.v(TAG, "timelapse: skipping intermediate frame"); |
| return true; |
| } else { |
| // Desired frame has arrived after mTimeBetweenTimeLapseFrameCaptureUs time: |
| // - Reset mLastTimeLapseFrameRealTimestampNs to current time. |
| // - Artificially modify timestampNs to be one frame time (1/framerate) ahead |
| // of the last encoded frame's time stamp. |
| if (mLogVerbose) Log.v(TAG, "timelapse: encoding frame, Timestamp t = " + timestampNs + |
| ", last real t= " + mLastTimeLapseFrameRealTimestampNs + |
| ", interval = " + mTimeBetweenTimeLapseFrameCaptureUs); |
| mLastTimeLapseFrameRealTimestampNs = timestampNs; |
| mTimestampNs = mTimestampNs + (1000000000L / (long)mFps); |
| if (mLogVerbose) Log.v(TAG, "timelapse: encoding frame, setting t = " |
| + mTimestampNs + ", delta t = " + (1000000000L / (long)mFps) + |
| ", fps = " + mFps ); |
| return false; |
| } |
| } |
| |
| @Override |
| public void process(FilterContext context) { |
| GLEnvironment glEnv = context.getGLEnvironment(); |
| // Get input frame |
| Frame input = pullInput("videoframe"); |
| |
| // Check if recording needs to start |
| if (!mRecordingActive && mRecording) { |
| startRecording(context); |
| } |
| // Check if recording needs to stop |
| if (mRecordingActive && !mRecording) { |
| stopRecording(context); |
| } |
| |
| if (!mRecordingActive) return; |
| |
| if (mCaptureTimeLapse) { |
| if (skipFrameAndModifyTimestamp(input.getTimestamp())) { |
| return; |
| } |
| } else { |
| mTimestampNs = input.getTimestamp(); |
| } |
| |
| // Activate our surface |
| glEnv.activateSurfaceWithId(mSurfaceId); |
| |
| // Process |
| mProgram.process(input, mScreen); |
| |
| // Set timestamp from input |
| glEnv.setSurfaceTimestamp(mTimestampNs); |
| // And swap buffers |
| glEnv.swapBuffers(); |
| mNumFramesEncoded++; |
| } |
| |
| private void stopRecording(FilterContext context) { |
| if (mLogVerbose) Log.v(TAG, "Stopping recording"); |
| |
| mRecordingActive = false; |
| mNumFramesEncoded = 0; |
| GLEnvironment glEnv = context.getGLEnvironment(); |
| // The following call will switch the surface_id to 0 |
| // (thus, calling eglMakeCurrent on surface with id 0) and |
| // then call eglDestroy on the surface. Hence, this will |
| // call disconnect the SurfaceMediaSource, which is needed to |
| // be called before calling Stop on the mediarecorder |
| if (mLogVerbose) Log.v(TAG, String.format("Unregistering surface %d", mSurfaceId)); |
| glEnv.unregisterSurfaceId(mSurfaceId); |
| try { |
| mMediaRecorder.stop(); |
| } catch (RuntimeException e) { |
| throw new MediaRecorderStopException("MediaRecorder.stop() failed!", e); |
| } |
| mMediaRecorder.release(); |
| mMediaRecorder = null; |
| |
| mScreen.release(); |
| mScreen = null; |
| |
| // Use an EffectsRecorder callback to forward a media finalization |
| // call so that it creates the video thumbnail, and whatever else needs |
| // to be done to finalize media. |
| if (mRecordingDoneListener != null) { |
| mRecordingDoneListener.onRecordingDone(); |
| } |
| } |
| |
| @Override |
| public void close(FilterContext context) { |
| if (mLogVerbose) Log.v(TAG, "Closing"); |
| if (mRecordingActive) stopRecording(context); |
| } |
| |
| @Override |
| public void tearDown(FilterContext context) { |
| // Release all the resources associated with the MediaRecorder |
| // and GLFrame members |
| if (mMediaRecorder != null) { |
| mMediaRecorder.release(); |
| } |
| if (mScreen != null) { |
| mScreen.release(); |
| } |
| |
| } |
| |
| } |
