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     /** Stream manipulation */
406     uint32_t mNextStreamId;
407     uint32_t mRawStreamCount;
408     uint32_t mProcessedStreamCount;
409     uint32_t mJpegStreamCount;
410 
411     uint32_t mNextReprocessStreamId;
412     uint32_t mReprocessStreamCount;
413 
414     KeyedVector<uint32_t, Stream> mStreams;
415     KeyedVector<uint32_t, ReprocessStream> mReprocessStreams;
416 
417     /** Simulated hardware interfaces */
418     sp<Sensor> mSensor;
419     sp<JpegCompressor> mJpegCompressor;
420 
421     /** Pipeline control threads */
422     sp<ConfigureThread> mConfigureThread;
423     sp<ReadoutThread>   mReadoutThread;
424     sp<ControlThread>   mControlThread;
425 };
426 
427 }; /* namespace android */
428 
429 #endif  /* HW_EMULATOR_CAMERA_EMULATED_FAKE_CAMERA2_H */
430