1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef CAMERA_SOURCE_TIME_LAPSE_H_ 18 19 #define CAMERA_SOURCE_TIME_LAPSE_H_ 20 21 #include <pthread.h> 22 23 #include <utils/RefBase.h> 24 #include <utils/threads.h> 25 #include <utils/String16.h> 26 27 namespace android { 28 29 namespace hardware { 30 class ICamera; 31 } 32 33 class IMemory; 34 class Camera; 35 36 class CameraSourceTimeLapse : public CameraSource { 37 public: 38 static CameraSourceTimeLapse *CreateFromCamera( 39 const sp<hardware::ICamera> &camera, 40 const sp<ICameraRecordingProxy> &proxy, 41 int32_t cameraId, 42 const String16& clientName, 43 uid_t clientUid, 44 pid_t clientPid, 45 Size videoSize, 46 int32_t videoFrameRate, 47 const sp<IGraphicBufferProducer>& surface, 48 int64_t timeBetweenTimeLapseFrameCaptureUs, 49 bool storeMetaDataInVideoBuffers = true); 50 51 virtual ~CameraSourceTimeLapse(); 52 53 // If the frame capture interval is large, read will block for a long time. 54 // Due to the way the mediaRecorder framework works, a stop() call from 55 // mediaRecorder waits until the read returns, causing a long wait for 56 // stop() to return. To avoid this, we can make read() return a copy of the 57 // last read frame with the same time stamp frequently. This keeps the 58 // read() call from blocking too long. Calling this function quickly 59 // captures another frame, keeps its copy, and enables this mode of read() 60 // returning quickly. 61 void startQuickReadReturns(); 62 63 private: 64 // size of the encoded video. 65 int32_t mVideoWidth; 66 int32_t mVideoHeight; 67 68 // Time between two frames in final video (1/frameRate) 69 int64_t mTimeBetweenTimeLapseVideoFramesUs; 70 71 // Real timestamp of the last encoded time lapse frame 72 int64_t mLastTimeLapseFrameRealTimestampUs; 73 74 // Variable set in dataCallbackTimestamp() to help skipCurrentFrame() 75 // to know if current frame needs to be skipped. 76 bool mSkipCurrentFrame; 77 78 // Lock for accessing mCameraIdle 79 Mutex mCameraIdleLock; 80 81 // Condition variable to wait on if camera is is not yet idle. Once the 82 // camera gets idle, this variable will be signalled. 83 Condition mCameraIdleCondition; 84 85 // True if camera is in preview mode and ready for takePicture(). 86 // False after a call to takePicture() but before the final compressed 87 // data callback has been called and preview has been restarted. 88 volatile bool mCameraIdle; 89 90 // True if stop() is waiting for camera to get idle, i.e. for the last 91 // takePicture() to complete. This is needed so that dataCallbackTimestamp() 92 // can return immediately. 93 volatile bool mStopWaitingForIdleCamera; 94 95 // Lock for accessing quick stop variables. 96 Mutex mQuickStopLock; 97 98 // mQuickStop is set to true if we use quick read() returns, otherwise it is set 99 // to false. Once in this mode read() return a copy of the last read frame 100 // with the same time stamp. See startQuickReadReturns(). 101 volatile bool mQuickStop; 102 103 // Forces the next frame passed to dataCallbackTimestamp() to be read 104 // as a time lapse frame. Used by startQuickReadReturns() so that the next 105 // frame wakes up any blocking read. 106 volatile bool mForceRead; 107 108 // Stores a copy of the MediaBuffer read in the last read() call after 109 // mQuickStop was true. 110 MediaBufferBase* mLastReadBufferCopy; 111 112 // Status code for last read. 113 status_t mLastReadStatus; 114 115 CameraSourceTimeLapse( 116 const sp<hardware::ICamera> &camera, 117 const sp<ICameraRecordingProxy> &proxy, 118 int32_t cameraId, 119 const String16& clientName, 120 uid_t clientUid, 121 pid_t clientPid, 122 Size videoSize, 123 int32_t videoFrameRate, 124 const sp<IGraphicBufferProducer>& surface, 125 int64_t timeBetweenTimeLapseFrameCaptureUs, 126 bool storeMetaDataInVideoBuffers = true); 127 128 // Wrapper over CameraSource::signalBufferReturned() to implement quick stop. 129 // It only handles the case when mLastReadBufferCopy is signalled. Otherwise 130 // it calls the base class' function. 131 virtual void signalBufferReturned(MediaBufferBase* buffer); 132 133 // Wrapper over CameraSource::read() to implement quick stop. 134 virtual status_t read(MediaBufferBase **buffer, const ReadOptions *options = NULL); 135 136 // mSkipCurrentFrame is set to true in dataCallbackTimestamp() if the current 137 // frame needs to be skipped and this function just returns the value of mSkipCurrentFrame. 138 virtual bool skipCurrentFrame(int64_t timestampUs); 139 140 // In the video camera case calls skipFrameAndModifyTimeStamp() to modify 141 // timestamp and set mSkipCurrentFrame. 142 // Then it calls the base CameraSource::dataCallbackTimestamp() 143 // This will be called in VIDEO_BUFFER_MODE_DATA_CALLBACK_YUV and 144 // VIDEO_BUFFER_MODE_DATA_CALLBACK_METADATA mode. 145 virtual void dataCallbackTimestamp(int64_t timestampUs, int32_t msgType, 146 const sp<IMemory> &data); 147 148 // In the video camera case calls skipFrameAndModifyTimeStamp() to modify 149 // timestamp and set mSkipCurrentFrame. 150 // Then it calls the base CameraSource::recordingFrameHandleCallbackTimestamp() or 151 // CameraSource::recordingFrameHandleCallbackTimestampBatch() 152 // This will be called in VIDEO_BUFFER_MODE_DATA_CALLBACK_METADATA mode when 153 // the metadata is VideoNativeHandleMetadata. 154 virtual void recordingFrameHandleCallbackTimestamp(int64_t timestampUs, 155 native_handle_t* handle); 156 157 // In the video camera case calls skipFrameAndModifyTimeStamp() to modify 158 // timestamp and set mSkipCurrentFrame. 159 // Then it calls the base CameraSource::recordingFrameHandleCallbackTimestamp() or 160 // CameraSource::recordingFrameHandleCallbackTimestampBatch() 161 // This will be called in VIDEO_BUFFER_MODE_DATA_CALLBACK_METADATA mode when 162 // the metadata is VideoNativeHandleMetadata. 163 virtual void recordingFrameHandleCallbackTimestampBatch( 164 const std::vector<int64_t>& timestampsUs, 165 const std::vector<native_handle_t*>& handles); 166 167 // Process a buffer item received in CameraSource::BufferQueueListener. 168 // This will be called in VIDEO_BUFFER_MODE_BUFFER_QUEUE mode. 169 virtual void processBufferQueueFrame(BufferItem& buffer); 170 171 // Convenience function to fill mLastReadBufferCopy from the just read 172 // buffer. 173 void fillLastReadBufferCopy(MediaBufferBase& sourceBuffer); 174 175 // If the passed in size (width x height) is a supported video/preview size, 176 // the function sets the camera's video/preview size to it and returns true. 177 // Otherwise returns false. 178 bool trySettingVideoSize(int32_t width, int32_t height); 179 180 // When video camera is used for time lapse capture, returns true 181 // until enough time has passed for the next time lapse frame. When 182 // the frame needs to be encoded, it returns false and also modifies 183 // the time stamp to be one frame time ahead of the last encoded 184 // frame's time stamp. 185 bool skipFrameAndModifyTimeStamp(int64_t *timestampUs); 186 187 // Wrapper to enter threadTimeLapseEntry() 188 static void *ThreadTimeLapseWrapper(void *me); 189 190 // Creates a copy of source_data into a new memory of final type MemoryBase. 191 sp<IMemory> createIMemoryCopy(const sp<IMemory> &source_data); 192 193 CameraSourceTimeLapse(const CameraSourceTimeLapse &); 194 CameraSourceTimeLapse &operator=(const CameraSourceTimeLapse &); 195 }; 196 197 } // namespace android 198 199 #endif // CAMERA_SOURCE_TIME_LAPSE_H_ 200
