Do not support still image capture mode for timelapse video recording

    virtual status_t setAudioEncoder(int ae) = 0;

    virtual status_t setOutputFile(const char* path) = 0;

    virtual status_t setOutputFile(int fd, int64_t offset, int64_t length) = 0;

    virtual status_t setOutputFileAuxiliary(int fd) = 0;

    virtual status_t setVideoSize(int width, int height) = 0;

    virtual status_t setVideoFrameRate(int frames_per_second) = 0;

    virtual status_t setParameters(const String8& params) = 0;

    status_t    setAudioEncoder(int ae);

    status_t    setOutputFile(const char* path);

    status_t    setOutputFile(int fd, int64_t offset, int64_t length);

    status_t    setOutputFileAuxiliary(int fd);

    status_t    setVideoSize(int width, int height);

    status_t    setVideoFrameRate(int frames_per_second);

    status_t    setParameters(const String8& params);

    bool                        mIsAudioEncoderSet;

    bool                        mIsVideoEncoderSet;

    bool                        mIsOutputFileSet;

    bool                        mIsAuxiliaryOutputFileSet;

    Mutex                       mLock;

    Mutex                       mNotifyLock;

};

    void startQuickReadReturns();

private:

    // If true, will use still camera takePicture() for time lapse frames

    // If false, will use the videocamera frames instead.

    bool mUseStillCameraForTimeLapse;

    // Size of picture taken from still camera. This may be larger than the size

    // of the video, as still camera may not support the exact video resolution

    // demanded. See setPictureSizeToClosestSupported().

    int32_t mPictureWidth;

    int32_t mPictureHeight;

    // size of the encoded video.

    int32_t mVideoWidth;

    int32_t mVideoHeight;

    // True if we need to crop the still camera image to get the video frame.

    bool mNeedCropping;

    // Start location of the cropping rectangle.

    int32_t mCropRectStartX;

    int32_t mCropRectStartY;

    // Time between capture of two frames during time lapse recording

    // Negative value indicates that timelapse is disabled.

    int64_t mTimeBetweenTimeLapseFrameCaptureUs;

    // Real timestamp of the last encoded time lapse frame

    int64_t mLastTimeLapseFrameRealTimestampUs;

    // Thread id of thread which takes still picture and sleeps in a loop.

    pthread_t mThreadTimeLapse;

    // Variable set in dataCallbackTimestamp() to help skipCurrentFrame()

    // to know if current frame needs to be skipped.

    bool mSkipCurrentFrame;

    // Lock for accessing quick stop variables.

    Mutex mQuickStopLock;

    // Condition variable to wake up still picture thread.

    Condition mTakePictureCondition;

    // mQuickStop is set to true if we use quick read() returns, otherwise it is set

    // to false. Once in this mode read() return a copy of the last read frame

    // with the same time stamp. See startQuickReadReturns().

    // Wrapper over CameraSource::read() to implement quick stop.

    virtual status_t read(MediaBuffer **buffer, const ReadOptions *options = NULL);

    // For still camera case starts a thread which calls camera's takePicture()

    // in a loop. For video camera case, just starts the camera's video recording.

    virtual void startCameraRecording();

    // For still camera case joins the thread created in startCameraRecording().

    // For video camera case, just stops the camera's video recording.

    virtual void stopCameraRecording();

    // For still camera case don't need to do anything as memory is locally

    // allocated with refcounting.

    // For video camera case just tell the camera to release the frame.

    virtual void releaseRecordingFrame(const sp<IMemory>& frame);

    // mSkipCurrentFrame is set to true in dataCallbackTimestamp() if the current

    // frame needs to be skipped and this function just returns the value of mSkipCurrentFrame.

    virtual bool skipCurrentFrame(int64_t timestampUs);

    // Handles the callback to handle raw frame data from the still camera.

    // Creates a copy of the frame data as the camera can reuse the frame memory

    // once this callback returns. The function also sets a new timstamp corresponding

    // to one frame time ahead of the last encoded frame's time stamp. It then

    // calls dataCallbackTimestamp() of the base class with the copied data and the

    // modified timestamp, which will think that it recieved the frame from a video

    // camera and proceed as usual.

    virtual void dataCallback(int32_t msgType, const sp<IMemory> &data);

    // In the video camera case calls skipFrameAndModifyTimeStamp() to modify

    // timestamp and set mSkipCurrentFrame.

    // Then it calls the base CameraSource::dataCallbackTimestamp()

    // Otherwise returns false.

    bool trySettingVideoSize(int32_t width, int32_t height);

    // The still camera may not support the demanded video width and height.

    // We look for the supported picture sizes from the still camera and

    // choose the smallest one with either dimensions higher than the corresponding

    // video dimensions. The still picture will be cropped to get the video frame.

    // The function returns true if the camera supports picture sizes greater than

    // or equal to the passed in width and height, and false otherwise.

    bool setPictureSizeToClosestSupported(int32_t width, int32_t height);

    // Computes the offset of the rectangle from where to start cropping the

    // still image into the video frame. We choose the center of the image to be

    // cropped. The offset is stored in (mCropRectStartX, mCropRectStartY).

    bool computeCropRectangleOffset();

    // Crops the source data into a smaller image starting at

    // (mCropRectStartX, mCropRectStartY) and of the size of the video frame.

    // The data is returned into a newly allocated IMemory.

    sp<IMemory> cropYUVImage(const sp<IMemory> &source_data);

    // When video camera is used for time lapse capture, returns true

    // until enough time has passed for the next time lapse frame. When

    // the frame needs to be encoded, it returns false and also modifies

    // Wrapper to enter threadTimeLapseEntry()

    static void *ThreadTimeLapseWrapper(void *me);

    // Runs a loop which sleeps until a still picture is required

    // and then calls mCamera->takePicture() to take the still picture.

    // Used only in the case mUseStillCameraForTimeLapse = true.

    void threadTimeLapseEntry();

    // Wrapper to enter threadStartPreview()

    static void *ThreadStartPreviewWrapper(void *me);

    // Starts the camera's preview.

    void threadStartPreview();

    // Starts thread ThreadStartPreviewWrapper() for restarting preview.

    // Needs to be done in a thread so that dataCallback() which calls this function

    // can return, and the camera can know that takePicture() is done.

    void restartPreview();

    // Creates a copy of source_data into a new memory of final type MemoryBase.

    sp<IMemory> createIMemoryCopy(const sp<IMemory> &source_data);

    SET_AUDIO_ENCODER,

    SET_OUTPUT_FILE_PATH,

    SET_OUTPUT_FILE_FD,

    SET_OUTPUT_FILE_AUXILIARY_FD,

    SET_VIDEO_SIZE,

    SET_VIDEO_FRAMERATE,

    SET_PARAMETERS,

        return reply.readInt32();

    }

    status_t setOutputFileAuxiliary(int fd) {

        LOGV("setOutputFileAuxiliary(%d)", fd);

        Parcel data, reply;

        data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());

        data.writeFileDescriptor(fd);

        remote()->transact(SET_OUTPUT_FILE_AUXILIARY_FD, data, &reply);

        return reply.readInt32();

    }

    status_t setVideoSize(int width, int height)

    {

        LOGV("setVideoSize(%dx%d)", width, height);

            ::close(fd);

            return NO_ERROR;

        } break;

        case SET_OUTPUT_FILE_AUXILIARY_FD: {

            LOGV("SET_OUTPUT_FILE_AUXILIARY_FD");

            CHECK_INTERFACE(IMediaRecorder, data, reply);

            int fd = dup(data.readFileDescriptor());

            reply->writeInt32(setOutputFileAuxiliary(fd));

            return NO_ERROR;

        } break;

        case SET_VIDEO_SIZE: {

            LOGV("SET_VIDEO_SIZE");

            CHECK_INTERFACE(IMediaRecorder, data, reply);

    return ret;

}

status_t MediaRecorder::setOutputFileAuxiliary(int fd)

{

    LOGV("setOutputFileAuxiliary(%d)", fd);

    if(mMediaRecorder == NULL) {

        LOGE("media recorder is not initialized yet");

        return INVALID_OPERATION;

    }

    if (mIsAuxiliaryOutputFileSet) {

        LOGE("output file has already been set");

        return INVALID_OPERATION;

    }

    if (!(mCurrentState & MEDIA_RECORDER_DATASOURCE_CONFIGURED)) {

        LOGE("setOutputFile called in an invalid state(%d)", mCurrentState);

        return INVALID_OPERATION;

    }

    status_t ret = mMediaRecorder->setOutputFileAuxiliary(fd);

    if (OK != ret) {

        LOGV("setOutputFileAuxiliary failed: %d", ret);

        mCurrentState = MEDIA_RECORDER_ERROR;

        return ret;

    }

    mIsAuxiliaryOutputFileSet = true;

    return ret;

}

status_t MediaRecorder::setVideoSize(int width, int height)

{

    LOGV("setVideoSize(%d, %d)", width, height);

    mIsAudioEncoderSet = false;

    mIsVideoEncoderSet = false;

    mIsOutputFileSet   = false;

    mIsAuxiliaryOutputFileSet = false;

}

// Release should be OK in any state