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