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