1 /* 2 * Copyright (C) 2012 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_CAMERA2_H 18 #define HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA2_H 19 20 /* 21 * Contains declaration of a class EmulatedFakeCamera2 that encapsulates 22 * functionality of a fake camera that implements version 2 of the camera device 23 * interface. 24 */ 25 26 #include "EmulatedCamera2.h" 27 #include "fake-pipeline2/Base.h" 28 #include "fake-pipeline2/Sensor.h" 29 #include "fake-pipeline2/JpegCompressor.h" 30 #include <utils/Condition.h> 31 #include <utils/KeyedVector.h> 32 #include <utils/String8.h> 33 #include <utils/String16.h> 34 35 namespace android { 36 37 /* Encapsulates functionality of an advanced fake camera. This camera contains 38 * a simple simulation of a scene, sensor, and image processing pipeline. 39 */ 40 class EmulatedFakeCamera2 : public EmulatedCamera2 { 41 public: 42 /* Constructs EmulatedFakeCamera instance. */ 43 EmulatedFakeCamera2(int cameraId, bool facingBack, struct hw_module_t* module); 44 45 /* Destructs EmulatedFakeCamera instance. */ 46 ~EmulatedFakeCamera2(); 47 48 /**************************************************************************** 49 * EmulatedCamera2 virtual overrides. 50 ***************************************************************************/ 51 52 public: 53 /* Initializes EmulatedFakeCamera2 instance. */ 54 status_t Initialize(); 55 56 /**************************************************************************** 57 * Camera Module API and generic hardware device API implementation 58 ***************************************************************************/ 59 public: 60 61 virtual status_t connectCamera(hw_device_t** device); 62 63 virtual status_t plugCamera(); 64 virtual status_t unplugCamera(); 65 virtual camera_device_status_t getHotplugStatus(); 66 67 virtual status_t closeCamera(); 68 69 virtual status_t getCameraInfo(struct camera_info *info); 70 71 /**************************************************************************** 72 * EmulatedCamera2 abstract API implementation. 73 ***************************************************************************/ 74 protected: 75 /** Request input queue */ 76 77 virtual int requestQueueNotify(); 78 79 /** Count of requests in flight */ 80 virtual int getInProgressCount(); 81 82 /** Cancel all captures in flight */ 83 //virtual int flushCapturesInProgress(); 84 85 /** Construct default request */ 86 virtual int constructDefaultRequest( 87 int request_template, 88 camera_metadata_t **request); 89 90 virtual int allocateStream( 91 uint32_t width, 92 uint32_t height, 93 int format, 94 const camera2_stream_ops_t *stream_ops, 95 uint32_t *stream_id, 96 uint32_t *format_actual, 97 uint32_t *usage, 98 uint32_t *max_buffers); 99 100 virtual int registerStreamBuffers( 101 uint32_t stream_id, 102 int num_buffers, 103 buffer_handle_t *buffers); 104 105 virtual int releaseStream(uint32_t stream_id); 106 107 // virtual int allocateReprocessStream( 108 // uint32_t width, 109 // uint32_t height, 110 // uint32_t format, 111 // const camera2_stream_ops_t *stream_ops, 112 // uint32_t *stream_id, 113 // uint32_t *format_actual, 114 // uint32_t *usage, 115 // uint32_t *max_buffers); 116 117 virtual int allocateReprocessStreamFromStream( 118 uint32_t output_stream_id, 119 const camera2_stream_in_ops_t *stream_ops, 120 uint32_t *stream_id); 121 122 virtual int releaseReprocessStream(uint32_t stream_id); 123 124 virtual int triggerAction(uint32_t trigger_id, 125 int32_t ext1, 126 int32_t ext2); 127 128 /** Debug methods */ 129 130 virtual int dump(int fd); 131 132 public: 133 /**************************************************************************** 134 * Utility methods called by configure/readout threads and pipeline 135 ***************************************************************************/ 136 137 // Get information about a given stream. Will lock mMutex 138 const Stream &getStreamInfo(uint32_t streamId); 139 const ReprocessStream &getReprocessStreamInfo(uint32_t streamId); 140 141 // Notifies rest of camera subsystem of serious error 142 void signalError(); 143 144 private: 145 /**************************************************************************** 146 * Utility methods 147 ***************************************************************************/ 148 /** Construct static camera metadata, two-pass */ 149 status_t constructStaticInfo( 150 camera_metadata_t **info, 151 bool sizeRequest) const; 152 153 /** Two-pass implementation of constructDefaultRequest */ 154 status_t constructDefaultRequest( 155 int request_template, 156 camera_metadata_t **request, 157 bool sizeRequest) const; 158 /** Helper function for constructDefaultRequest */ 159 static status_t addOrSize( camera_metadata_t *request, 160 bool sizeRequest, 161 size_t *entryCount, 162 size_t *dataCount, 163 uint32_t tag, 164 const void *entry_data, 165 size_t entry_count); 166 167 /** Determine if the stream id is listed in any currently-in-flight 168 * requests. Assumes mMutex is locked */ 169 bool isStreamInUse(uint32_t streamId); 170 171 /** Determine if the reprocess stream id is listed in any 172 * currently-in-flight requests. Assumes mMutex is locked */ 173 bool isReprocessStreamInUse(uint32_t streamId); 174 175 /**************************************************************************** 176 * Pipeline controller threads 177 ***************************************************************************/ 178 179 class ConfigureThread: public Thread { 180 public: 181 ConfigureThread(EmulatedFakeCamera2 *parent); 182 ~ConfigureThread(); 183 184 status_t waitUntilRunning(); 185 status_t newRequestAvailable(); 186 status_t readyToRun(); 187 188 bool isStreamInUse(uint32_t id); 189 int getInProgressCount(); 190 private: 191 EmulatedFakeCamera2 *mParent; 192 static const nsecs_t kWaitPerLoop = 10000000L; // 10 ms 193 194 bool mRunning; 195 bool threadLoop(); 196 197 bool setupCapture(); 198 bool setupReprocess(); 199 200 bool configureNextCapture(); 201 bool configureNextReprocess(); 202 203 bool getBuffers(); 204 205 Mutex mInputMutex; // Protects mActive, mRequestCount 206 Condition mInputSignal; 207 bool mActive; // Whether we're waiting for input requests or actively 208 // working on them 209 size_t mRequestCount; 210 211 camera_metadata_t *mRequest; 212 213 Mutex mInternalsMutex; // Lock before accessing below members. 214 bool mWaitingForReadout; 215 bool mNextNeedsJpeg; 216 bool mNextIsCapture; 217 int32_t mNextFrameNumber; 218 int64_t mNextExposureTime; 219 int64_t mNextFrameDuration; 220 int32_t mNextSensitivity; 221 Buffers *mNextBuffers; 222 }; 223 224 class ReadoutThread: public Thread, private JpegCompressor::JpegListener { 225 public: 226 ReadoutThread(EmulatedFakeCamera2 *parent); 227 ~ReadoutThread(); 228 229 status_t readyToRun(); 230 231 // Input 232 status_t waitUntilRunning(); 233 bool waitForReady(nsecs_t timeout); 234 void setNextOperation(bool isCapture, 235 camera_metadata_t *request, 236 Buffers *buffers); 237 bool isStreamInUse(uint32_t id); 238 int getInProgressCount(); 239 private: 240 EmulatedFakeCamera2 *mParent; 241 242 bool mRunning; 243 bool threadLoop(); 244 245 bool readyForNextCapture(); 246 status_t collectStatisticsMetadata(camera_metadata_t *frame); 247 248 // Inputs 249 Mutex mInputMutex; // Protects mActive, mInFlightQueue, mRequestCount 250 Condition mInputSignal; 251 Condition mReadySignal; 252 253 bool mActive; 254 255 static const int kInFlightQueueSize = 4; 256 struct InFlightQueue { 257 bool isCapture; 258 camera_metadata_t *request; 259 Buffers *buffers; 260 } *mInFlightQueue; 261 262 size_t mInFlightHead; 263 size_t mInFlightTail; 264 265 size_t mRequestCount; 266 267 // Internals 268 Mutex mInternalsMutex; 269 270 bool mIsCapture; 271 camera_metadata_t *mRequest; 272 Buffers *mBuffers; 273 274 // Jpeg completion listeners 275 void onJpegDone(const StreamBuffer &jpegBuffer, bool success); 276 void onJpegInputDone(const StreamBuffer &inputBuffer); 277 nsecs_t mJpegTimestamp; 278 }; 279 280 // 3A management thread (auto-exposure, focus, white balance) 281 class ControlThread: public Thread { 282 public: 283 ControlThread(EmulatedFakeCamera2 *parent); 284 ~ControlThread(); 285 286 status_t readyToRun(); 287 288 status_t waitUntilRunning(); 289 290 // Interpret request's control parameters and override 291 // capture settings as needed 292 status_t processRequest(camera_metadata_t *request); 293 294 status_t triggerAction(uint32_t msgType, 295 int32_t ext1, int32_t ext2); 296 private: 297 ControlThread(const ControlThread &t); 298 ControlThread& operator=(const ControlThread &t); 299 300 // Constants controlling fake 3A behavior 301 static const nsecs_t kControlCycleDelay; 302 static const nsecs_t kMinAfDuration; 303 static const nsecs_t kMaxAfDuration; 304 static const float kAfSuccessRate; 305 static const float kContinuousAfStartRate; 306 307 static const float kAeScanStartRate; 308 static const nsecs_t kMinAeDuration; 309 static const nsecs_t kMaxAeDuration; 310 static const nsecs_t kMinPrecaptureAeDuration; 311 static const nsecs_t kMaxPrecaptureAeDuration; 312 313 static const nsecs_t kNormalExposureTime; 314 static const nsecs_t kExposureJump; 315 static const nsecs_t kMinExposureTime; 316 317 EmulatedFakeCamera2 *mParent; 318 319 bool mRunning; 320 bool threadLoop(); 321 322 Mutex mInputMutex; // Protects input methods 323 Condition mInputSignal; 324 325 // Trigger notifications 326 bool mStartAf; 327 bool mCancelAf; 328 bool mStartPrecapture; 329 330 // Latest state for 3A request fields 331 uint8_t mControlMode; 332 333 uint8_t mEffectMode; 334 uint8_t mSceneMode; 335 336 uint8_t mAfMode; 337 bool mAfModeChange; 338 339 uint8_t mAwbMode; 340 uint8_t mAeMode; 341 342 // Latest trigger IDs 343 int32_t mAfTriggerId; 344 int32_t mPrecaptureTriggerId; 345 346 // Current state for 3A algorithms 347 uint8_t mAfState; 348 uint8_t mAeState; 349 uint8_t mAwbState; 350 bool mAeLock; 351 352 // Current control parameters 353 nsecs_t mExposureTime; 354 355 // Private to threadLoop and its utility methods 356 357 nsecs_t mAfScanDuration; 358 nsecs_t mAeScanDuration; 359 bool mLockAfterPassiveScan; 360 361 // Utility methods for AF 362 int processAfTrigger(uint8_t afMode, uint8_t afState); 363 int maybeStartAfScan(uint8_t afMode, uint8_t afState); 364 int updateAfScan(uint8_t afMode, uint8_t afState, nsecs_t *maxSleep); 365 void updateAfState(uint8_t newState, int32_t triggerId); 366 367 // Utility methods for precapture trigger 368 int processPrecaptureTrigger(uint8_t aeMode, uint8_t aeState); 369 int maybeStartAeScan(uint8_t aeMode, bool aeLock, uint8_t aeState); 370 int updateAeScan(uint8_t aeMode, bool aeLock, uint8_t aeState, 371 nsecs_t *maxSleep); 372 void updateAeState(uint8_t newState, int32_t triggerId); 373 }; 374 375 /**************************************************************************** 376 * Static configuration information 377 ***************************************************************************/ 378 private: 379 static const uint32_t kMaxRawStreamCount = 1; 380 static const uint32_t kMaxProcessedStreamCount = 3; 381 static const uint32_t kMaxJpegStreamCount = 1; 382 static const uint32_t kMaxReprocessStreamCount = 2; 383 static const uint32_t kMaxBufferCount = 4; 384 static const uint32_t kAvailableFormats[]; 385 static const uint32_t kAvailableRawSizes[]; 386 static const uint64_t kAvailableRawMinDurations[]; 387 static const uint32_t kAvailableProcessedSizesBack[]; 388 static const uint32_t kAvailableProcessedSizesFront[]; 389 static const uint64_t kAvailableProcessedMinDurations[]; 390 static const uint32_t kAvailableJpegSizesBack[]; 391 static const uint32_t kAvailableJpegSizesFront[]; 392 static const uint64_t kAvailableJpegMinDurations[]; 393 394 /**************************************************************************** 395 * Data members. 396 ***************************************************************************/ 397 398 protected: 399 /* Facing back (true) or front (false) switch. */ 400 bool mFacingBack; 401 402 private: 403 bool mIsConnected; 404 405 int32_t mSensorWidth, mSensorHeight; 406 407 /** Stream manipulation */ 408 uint32_t mNextStreamId; 409 uint32_t mRawStreamCount; 410 uint32_t mProcessedStreamCount; 411 uint32_t mJpegStreamCount; 412 413 uint32_t mNextReprocessStreamId; 414 uint32_t mReprocessStreamCount; 415 416 KeyedVector<uint32_t, Stream> mStreams; 417 KeyedVector<uint32_t, ReprocessStream> mReprocessStreams; 418 419 /** Simulated hardware interfaces */ 420 sp<Sensor> mSensor; 421 sp<JpegCompressor> mJpegCompressor; 422 423 /** Pipeline control threads */ 424 sp<ConfigureThread> mConfigureThread; 425 sp<ReadoutThread> mReadoutThread; 426 sp<ControlThread> mControlThread; 427 }; 428 429 }; /* namespace android */ 430 431 #endif /* HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA2_H */ 432
