1 /* 2 * Copyright (C) 2013 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 HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA3_H 18 #define HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA3_H 19 20 /** 21 * Contains declaration of a class EmulatedCamera that encapsulates 22 * functionality of a fake camera that implements version 3 of the camera device 23 * interace. 24 */ 25 26 #include "EmulatedCamera3.h" 27 #include "fake-pipeline2/Base.h" 28 #include "fake-pipeline2/Sensor.h" 29 #include "fake-pipeline2/JpegCompressor.h" 30 #include <camera/CameraMetadata.h> 31 #include <utils/SortedVector.h> 32 #include <utils/List.h> 33 #include <utils/Mutex.h> 34 35 namespace android { 36 37 /** 38 * Encapsulates functionality for a v3 HAL camera which produces synthetic data. 39 * 40 * Note that EmulatedCameraFactory instantiates an object of this class just 41 * once, when EmulatedCameraFactory instance gets constructed. Connection to / 42 * disconnection from the actual camera device is handled by calls to 43 * connectDevice(), and closeCamera() methods of this class that are invoked in 44 * response to hw_module_methods_t::open, and camera_device::close callbacks. 45 */ 46 class EmulatedFakeCamera3 : public EmulatedCamera3, 47 private Sensor::SensorListener { 48 public: 49 50 EmulatedFakeCamera3(int cameraId, bool facingBack, 51 struct hw_module_t* module); 52 53 virtual ~EmulatedFakeCamera3(); 54 55 /**************************************************************************** 56 * EmulatedCamera3 virtual overrides 57 ***************************************************************************/ 58 59 public: 60 61 virtual status_t Initialize(); 62 63 /**************************************************************************** 64 * Camera module API and generic hardware device API implementation 65 ***************************************************************************/ 66 67 public: 68 virtual status_t connectCamera(hw_device_t** device); 69 70 virtual status_t closeCamera(); 71 72 virtual status_t getCameraInfo(struct camera_info *info); 73 74 /**************************************************************************** 75 * EmulatedCamera3 abstract API implementation 76 ***************************************************************************/ 77 78 protected: 79 80 virtual status_t configureStreams( 81 camera3_stream_configuration *streamList); 82 83 virtual status_t registerStreamBuffers( 84 const camera3_stream_buffer_set *bufferSet) ; 85 86 virtual const camera_metadata_t* constructDefaultRequestSettings( 87 int type); 88 89 virtual status_t processCaptureRequest(camera3_capture_request *request); 90 91 virtual status_t flush(); 92 93 /** Debug methods */ 94 95 virtual void dump(int fd); 96 97 private: 98 99 /** 100 * Get the requested capability set for this camera 101 */ 102 status_t getCameraCapabilities(); 103 104 bool hasCapability(AvailableCapabilities cap); 105 106 /** 107 * Build the static info metadata buffer for this device 108 */ 109 status_t constructStaticInfo(); 110 111 /** 112 * Run the fake 3A algorithms as needed. May override/modify settings 113 * values. 114 */ 115 status_t process3A(CameraMetadata &settings); 116 117 status_t doFakeAE(CameraMetadata &settings); 118 status_t doFakeAF(CameraMetadata &settings); 119 status_t doFakeAWB(CameraMetadata &settings); 120 void update3A(CameraMetadata &settings); 121 122 /** Signal from readout thread that it doesn't have anything to do */ 123 void signalReadoutIdle(); 124 125 /** Handle interrupt events from the sensor */ 126 void onSensorEvent(uint32_t frameNumber, Event e, nsecs_t timestamp); 127 128 /**************************************************************************** 129 * Static configuration information 130 ***************************************************************************/ 131 private: 132 static const uint32_t kMaxRawStreamCount = 1; 133 static const uint32_t kMaxProcessedStreamCount = 3; 134 static const uint32_t kMaxJpegStreamCount = 1; 135 static const uint32_t kMaxReprocessStreamCount = 2; 136 static const uint32_t kMaxBufferCount = 4; 137 // We need a positive stream ID to distinguish external buffers from 138 // sensor-generated buffers which use a nonpositive ID. Otherwise, HAL3 has 139 // no concept of a stream id. 140 static const uint32_t kGenericStreamId = 1; 141 static const int32_t kAvailableFormats[]; 142 143 static const int64_t kSyncWaitTimeout = 10000000; // 10 ms 144 static const int32_t kMaxSyncTimeoutCount = 1000; // 1000 kSyncWaitTimeouts 145 static const uint32_t kFenceTimeoutMs = 2000; // 2 s 146 147 /**************************************************************************** 148 * Data members. 149 ***************************************************************************/ 150 151 /* HAL interface serialization lock. */ 152 Mutex mLock; 153 154 /* Facing back (true) or front (false) switch. */ 155 bool mFacingBack; 156 157 SortedVector<AvailableCapabilities> mCapabilities; 158 159 /** 160 * Cache for default templates. Once one is requested, the pointer must be 161 * valid at least until close() is called on the device 162 */ 163 camera_metadata_t *mDefaultTemplates[CAMERA3_TEMPLATE_COUNT]; 164 165 /** 166 * Private stream information, stored in camera3_stream_t->priv. 167 */ 168 struct PrivateStreamInfo { 169 bool alive; 170 }; 171 172 // Shortcut to the input stream 173 camera3_stream_t* mInputStream; 174 175 typedef List<camera3_stream_t*> StreamList; 176 typedef List<camera3_stream_t*>::iterator StreamIterator; 177 typedef Vector<camera3_stream_buffer> HalBufferVector; 178 179 // All streams, including input stream 180 StreamList mStreams; 181 182 // Cached settings from latest submitted request 183 CameraMetadata mPrevSettings; 184 185 /** Fake hardware interfaces */ 186 sp<Sensor> mSensor; 187 sp<JpegCompressor> mJpegCompressor; 188 friend class JpegCompressor; 189 190 /** Processing thread for sending out results */ 191 192 class ReadoutThread : public Thread, private JpegCompressor::JpegListener { 193 public: 194 ReadoutThread(EmulatedFakeCamera3 *parent); 195 ~ReadoutThread(); 196 197 struct Request { 198 uint32_t frameNumber; 199 CameraMetadata settings; 200 HalBufferVector *buffers; 201 Buffers *sensorBuffers; 202 }; 203 204 /** 205 * Interface to parent class 206 */ 207 208 // Place request in the in-flight queue to wait for sensor capture 209 void queueCaptureRequest(const Request &r); 210 211 // Test if the readout thread is idle (no in-flight requests, not 212 // currently reading out anything 213 bool isIdle(); 214 215 // Wait until isIdle is true 216 status_t waitForReadout(); 217 218 private: 219 static const nsecs_t kWaitPerLoop = 10000000L; // 10 ms 220 static const nsecs_t kMaxWaitLoops = 1000; 221 static const size_t kMaxQueueSize = 2; 222 223 EmulatedFakeCamera3 *mParent; 224 Mutex mLock; 225 226 List<Request> mInFlightQueue; 227 Condition mInFlightSignal; 228 bool mThreadActive; 229 230 virtual bool threadLoop(); 231 232 // Only accessed by threadLoop 233 234 Request mCurrentRequest; 235 236 // Jpeg completion callbacks 237 238 Mutex mJpegLock; 239 bool mJpegWaiting; 240 camera3_stream_buffer mJpegHalBuffer; 241 uint32_t mJpegFrameNumber; 242 virtual void onJpegDone(const StreamBuffer &jpegBuffer, bool success); 243 virtual void onJpegInputDone(const StreamBuffer &inputBuffer); 244 }; 245 246 sp<ReadoutThread> mReadoutThread; 247 248 /** Fake 3A constants */ 249 250 static const nsecs_t kNormalExposureTime; 251 static const nsecs_t kFacePriorityExposureTime; 252 static const int kNormalSensitivity; 253 static const int kFacePrioritySensitivity; 254 // Rate of converging AE to new target value, as fraction of difference between 255 // current and target value. 256 static const float kExposureTrackRate; 257 // Minimum duration for precapture state. May be longer if slow to converge 258 // to target exposure 259 static const int kPrecaptureMinFrames; 260 // How often to restart AE 'scanning' 261 static const int kStableAeMaxFrames; 262 // Maximum stop below 'normal' exposure time that we'll wander to while 263 // pretending to converge AE. In powers of 2. (-2 == 1/4 as bright) 264 static const float kExposureWanderMin; 265 // Maximum stop above 'normal' exposure time that we'll wander to while 266 // pretending to converge AE. In powers of 2. (2 == 4x as bright) 267 static const float kExposureWanderMax; 268 269 /** Fake 3A state */ 270 271 uint8_t mControlMode; 272 bool mFacePriority; 273 uint8_t mAeState; 274 uint8_t mAfState; 275 uint8_t mAwbState; 276 uint8_t mAeMode; 277 uint8_t mAfMode; 278 uint8_t mAwbMode; 279 280 int mAeCounter; 281 nsecs_t mAeCurrentExposureTime; 282 nsecs_t mAeTargetExposureTime; 283 int mAeCurrentSensitivity; 284 285 }; 286 287 } // namespace android 288 289 #endif // HW_EMULATOR_CAMERA_EMULATED_CAMERA3_H 290